package android.support.design;

import android.accounts.Account;
import android.accounts.AccountManager;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.Dialog;
import android.app.DownloadManager;
import android.app.KeyguardManager;
import android.app.Notification;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
import android.content.ContextWrapper;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.content.SharedPreferences;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.Signature;
import android.content.res.TypedArray;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.DrawableContainer;
import android.graphics.drawable.GradientDrawable;
import android.media.ExifInterface;
import android.media.session.PlaybackState;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.TrafficStats;
import android.net.Uri;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Debug;
import android.os.Environment;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Parcel;
import android.os.PowerManager;
import android.os.Process;
import android.os.Trace;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.RequiresApi;
import android.support.design.internal.ParcelableSparseArray;
import android.support.graphics.drawable.VectorDrawableCompat;
import android.support.v4.app.AppOpsManagerCompat;
import android.support.v4.app.NotificationCompat;
import android.support.v4.app.NotificationCompat.BigPictureStyle;
import android.support.v4.app.NotificationCompat.BigTextStyle;
import android.support.v4.content.ContextCompat;
import android.support.v4.graphics.drawable.DrawableCompat;
import android.support.v4.os.ParcelableCompatCreatorCallbacks;
import android.support.v4.util.ArrayMap;
import android.support.v4.view.animation.PathInterpolatorCompat;
import android.telephony.TelephonyManager;
import android.text.SpannableString;
import android.text.TextUtils;
import android.text.style.ForegroundColorSpan;
import android.transition.Transition;
import android.transition.TransitionSet;
import android.util.AttributeSet;
import android.util.Base64;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.Pair;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.Window;
import android.view.animation.Interpolator;
import android.view.inputmethod.InputMethodManager;
import android.widget.ArrayAdapter;
import android.widget.EdgeEffect;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.a.a.NightMode;
import com.a.a.o;
import com.bytedance.article.common.c.TTUtils;
import com.bytedance.article.common.launchcrash.launchNetUtils$CompressType;
import com.bytedance.common.utility.Logger;
import com.bytedance.common.utility.NetworkType;
import com.bytedance.common.utility.UIUtils;
import com.bytedance.common.utility.c.SharedPreferenceCompat;
import com.bytedance.common.utility.reflect.Reflect;
import com.bytedance.frameworks.b.a.ComponentsManifest;
import com.bytedance.frameworks.baselib.network.http.AppConfig;
import com.bytedance.frameworks.baselib.network.http.exception.ClientProtocolException;
import com.bytedance.frameworks.baselib.network.http.exception.HttpResponseException;
import com.bytedance.frameworks.baselib.network.http.exception.NoHttpResponseException;
import com.bytedance.frameworks.baselib.network.http.util.DownloadFileTooLargeException;
import com.bytedance.frameworks.baselib.network.http.util.TaskInfo;
import com.bytedance.frameworks.core.a.i;
import com.bytedance.frameworks.core.a.j;
import com.bytedance.frameworks.core.encrypt.TTEncryptUtils;
import com.bytedance.retrofit2.Callback;
import com.bytedance.retrofit2.mime.FormUrlEncodedTypedOutput;
import com.bytedance.retrofit2.mime.MimeUtil;
import com.bytedance.retrofit2.mime.TypedOutput;
import com.bytedance.ttnet.b.GetDomainContext;
import com.bytedance.ttnet.utils.RetrofitUtils;
import com.facebook.common.internal.ToStringHelper;
import com.facebook.drawee.generic.GenericDraweeHierarchy;
import com.google.gson.JsonElement;
import com.google.gson.JsonIOException;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSyntaxException;
import com.google.gson.internal.bind.TypeAdapters;
import com.google.gson.stream.JsonWriter;
import com.google.gson.stream.MalformedJsonException;
import com.ss.android.account.e.f;
import com.ss.android.article.base.app.AppData;
import com.ss.android.article.base.feature.app.a.ArticleConstants;
import com.ss.android.article.base.feature.c.FeedPresenter;
import com.ss.android.article.base.feature.detail.model.ArticleDetail;
import com.ss.android.article.base.feature.feed.presenter.ArticleQueryObj;
import com.ss.android.article.base.feature.feed.presenter.LastReadDataManager;
import com.ss.android.article.base.feature.feed.vh.CardViewPools;
import com.ss.android.article.base.feature.model.Article;
import com.ss.android.article.base.feature.model.CellRef;
import com.ss.android.article.base.feature.subscribe.model.EntryGroup;
import com.ss.android.article.base.feature.subscribe.model.EntryItem;
import com.ss.android.article.base.ui.NoNetView;
import com.ss.android.article.base.ui.PriorityLinearLayout;
import com.ss.android.article.base.ui.ab;
import com.ss.android.article.base.ui.ac;
import com.ss.android.article.base.ui.ad;
import com.ss.android.article.base.utils.a.SharedPreferenceUtils;
import com.ss.android.article.browser.api.BrowserISApi;
import com.ss.android.article.browser.constant.Constants;
import com.ss.android.article.browser.constant.WebsiteNaviItem;
import com.ss.android.article.browser.setting.DefaultSettingHandler$Status;
import com.ss.android.article.browser.website.NavigationBean;
import com.ss.android.article.common.entity.ShareEntity;
import com.ss.android.article.common.model.ShareData;
import com.ss.android.article.common.share.abs.AbsShareHelper;
import com.ss.android.article.common.share.log.ShareBaseResp;
import com.ss.android.article.common.share.log.ShareRespEntry;
import com.ss.android.browser.base.wrapper.net.RetrofitWrapper;
import com.ss.android.common.AbsApiThread;
import com.ss.android.common.app.AbsApplication;
import com.ss.android.common.app.IComponent;
import com.ss.android.common.applog.AppLog;
import com.ss.android.common.dialog.AlertDialog;
import com.ss.android.common.download.h;
import com.ss.android.common.lib.MobClickCombiner;
import com.ss.android.common.ui.view.SuperToast;
import com.ss.android.common.ui.view.SwipeOverlayFrameLayout;
import com.ss.android.common.util.DeviceUtils;
import com.ss.android.common.util.NetworkUtils;
import com.ss.android.common.util.ToolUtils;
import com.ss.android.common.util.TtProperties;
import com.ss.android.common.util.UrlBuilder;
import com.ss.android.common.util.json.JsonUtil;
import com.ss.android.crash.log.CrashUtils;
import com.ss.android.http.legacy.HttpHeader;
import com.ss.android.image.AsyncImageView;
import com.ss.android.image.FrescoUtils;
import com.ss.android.image.Image;
import com.ss.android.image.a.a.TTDraweeControllerBuilderSupplier;
import com.ss.android.image.loader.ImageLoader;
import com.ss.android.image.model.ImageInfo;
import com.ss.android.k.d.LayoutInflaterInterceptor;
import com.ss.android.newmedia.BaseAppData;
import com.ss.android.newmedia.a.AdsAppBaseActivity;
import com.ss.android.newmedia.activity.AbsSplashActivity;
import com.ss.android.newmedia.activity.browser.BrowserActivity;
import com.ss.android.newmedia.e.AlertManager;
import com.ss.android.newmedia.message.dialog.s;
import com.ss.android.newmedia.message.dialog.t;
import com.ss.android.newmedia.message.dialog.x;
import com.ss.android.newmedia.util.AppUtil;
import com.ss.android.topic.tips.TipsType;
import com.ss.android.wenda.IWendaApi;
import com.ss.android.wenda.entity.AbstractEntity;
import com.ss.android.wenda.entity.AnswerEntity;
import com.ss.android.wenda.entity.UserEntity;
import com.ss.android.wenda.model.Answer;
import com.ss.android.wenda.model.AnswerAbstract;
import com.ss.android.wenda.model.User;
import com.tencent.mm.opensdk.modelbase.BaseReq;
import com.tencent.mm.opensdk.modelmsg.SendAuth.Req;
import com.tencent.mm.opensdk.openapi.IWXAPI;

import org.apache.http.conn.ConnectTimeoutException;
import org.jetbrains.annotations.NotNull;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.BindException;
import java.net.ConnectException;
import java.net.HttpURLConnection;
import java.net.NetworkInterface;
import java.net.NoRouteToHostException;
import java.net.PortUnreachableException;
import java.net.ProtocolException;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.net.UnknownHostException;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyFactory;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.Deflater;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipFile;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;

import inline.BitmapDemo;
import inline.NetworkDemo;
import inline.TextDemo;
import inline.UrlDemo;
import okhttp3.HttpUrl;

public class a implements ParcelableCompatCreatorCallbacks, NightMode {
    public static Context sContext;
    public static com.ss.android.lockscreen.c.a.a B;
    public static KeyguardManager C;
    public static KeyguardManager.KeyguardLock D;
    public static MobClickCombiner.IUmengAgent sUmengAgent;
    public static Field a;
    public static boolean b;
    public static Field c;
    public static boolean d;
    @Nullable
    public static o e;
    @Nullable
    public static o f;
    public static j g;
    public static i h;
    public static boolean i;
    public static boolean j;
    public static boolean k;
    public static boolean l;
    public static long m;
    public static long n;
    public static boolean o;
    public static boolean p;
    public static volatile Map q;
    public static Comparator<FeedPresenter> mFeedPresenterComparator;
    public static List s;
    public static boolean t;
    public static h u;
    public static com.ss.android.common.download.g v;
    public static String w;
    public static String x;
    public static Boolean y;
    public static TTDraweeControllerBuilderSupplier sTTDraweeControllerBuilderSupplier;
    private static Method F;
    private static boolean G;
    private static Field H;
    private static boolean I;
    private static Field J;
    private static boolean K;
    private static Field L;
    private static boolean M;
    @Nullable
    private static o N;
    @Nullable
    private static o O;
    private static WeakReference P;
    private static WeakReference Q;
    private static boolean R;
    private static boolean S;
    private static List mWebsiteNavigationBeanList;
    private static int U;
    private static long V;
    private static Boolean W;
    private static SuperToast X;
    private static StringBuilder Y;
    private static String[] Z;

    public a() {

    }

    public a(Field arg1) {
        android.support.design.a.d(arg1);
    }

    public static Drawable getLiveVideoTipDrawable(Context context) {
        return ContextCompat.getDrawable(context, com.ss.android.article.browser.R.drawable.live_video_tip);
    }

    public static String[] A(String arg2) {
        return new String[]{arg2};
    }

    public static LayoutInflater createInterceptLayoutInflater(Context context) {
        LayoutInflater inflater = LayoutInflater.from(context).cloneInContext(context);
        inflater.setFactory(new LayoutInflaterInterceptor(inflater));
        return inflater;
    }

    private static String B() {
        String v1_1;
        int v1;
        StringBuilder v6;
        byte[] v5;
        String v2 = null;
        try {
            Enumeration v4 = NetworkInterface.getNetworkInterfaces();
            do {
                label_3:
                if (!v4.hasMoreElements()) {
                    return null;
                }

                Object v0_1 = v4.nextElement();
                v5 = ((NetworkInterface) v0_1).getHardwareAddress();
                if (v5 == null) {
                    continue;
                }

                if (v5.length == 0) {
                    continue;
                }

                v6 = new StringBuilder();
                int v7 = v5.length;
                v1 = 0;
                while (v1 < v7) {
                    v6.append(String.format("%02X:", Byte.valueOf(v5[v1])));
                    ++v1;
                }

                if (v6.length() > 0) {
                    v6.deleteCharAt(v6.length() - 1);
                }

                v1_1 = v6.toString();
                if (!((NetworkInterface) v0_1).getName().equals("wlan0")) {
                    continue;
                }
                return v1_1;
            } while (true);
        } catch (SocketException ex) {
            return null;
        }
    }

    public static void B(String arg2) {
        if (com.ss.ttm.player.m.a(6)) {
            i(Environment.getExternalStorageDirectory() + "/ttplayer.dump", arg2);
        } else {
            File v0 = new File(arg2);
            if (v0.exists()) {
                v0.delete();
            }
        }
    }

    private static int C() {
        return com.bytedance.framwork.core.monitor.c.j() != null
                ? NetworkDemo.b(com.bytedance.framwork.core.monitor.c.j().a.getApplicationContext()).getValue()
                : 0;
    }

    public static String C(Context arg3) {
        String v1;
        String v0 = null;
        if (com.ss.ttm.player.m.a(18, 1) == 1) {
            v1 = com.ss.ttm.player.m.c(arg3);
            if (v1 != null && (new File(v1).exists())) {
                v0 = v1;
            }
        } else {
            v1 = com.ss.ttm.player.m.a(arg3);
            if (v1 != null && (new File(v1).exists())) {
                return v1;
            }

            v1 = com.ss.ttm.player.m.b();
            if (v1 != null && (new File(v1).exists())) {
                return v1;
            }

            v1 = com.ss.ttm.player.m.c();
            if (v1 != null && !new File(v1).exists()) {
                return v0;
            }

            v0 = v1;
        }

        return v0;
    }

    public static String C(String arg2) {
        return Base64.encodeToString(arg2.getBytes(), 0);
    }

    public static void D(String arg5) {
        int v0 = 0;
        File v1 = new File(String.format("%s/ttplayer_logs", arg5));
        if (!v1.exists()) {
            v1.mkdir();
        } else if (v1.isDirectory()) {
            File[] v2 = v1.listFiles();
            int v3 = v2.length;
            while (v0 < v3) {
                v2[v0].delete();
                ++v0;
            }

            v1.delete();
        }
    }

    private static boolean isDevOrTestChannel() {
        try {
            AbsApplication application = AbsApplication.getApplication();
            String channel = application.getChannel();
            if (TextUtils.isEmpty(((CharSequence) channel))) {
                channel = TtProperties.getInstance(application).getString("meta_umeng_channel", "");
            }
            return "local_test".equals(channel) || "local_dev".equals(channel);
        } catch (Throwable throwable) {
        }
        return false;
    }

    private static Signature[] D(Context arg4) {
        Signature[] v0_1;
        try {
            v0_1 = arg4.getPackageManager().getPackageInfo(arg4.getPackageName(), PackageManager.GET_SIGNATURES).signatures;
        } catch (Exception v0) {
            Logger.w("SignUtils", "failed to get package signatures: " + v0);
            v0_1 = null;
        }

        return v0_1;
    }

    private static Bitmap E(Context arg4) {
        Bitmap v0 = null;
        try {
            Bitmap v1_1 = BitmapFactory.decodeResource(arg4.getApplicationContext().getResources(), com.ss.android.article.browser.R.drawable.ly);
            if (v1_1 == null) {
                return v0;
            }

            v0 = v1_1.copy(Bitmap.Config.ARGB_8888, true);
            v1_1.recycle();
        } catch (Exception v1) {
            Logger.throwExceptionInDebug(((Throwable) v1));
        }

        return v0;
    }

    public static String base64Decode(String input) {
        if (!TextUtils.isEmpty(input)) {
            try {
                return new String(Base64.decode(input, 0), "utf-8");
            } catch (Throwable throwable) {
            }
        }
        return "";
    }

    private static String[] E() {
        int v7 = 3;
        int v5 = 2;
        if (android.support.design.a.Z == null) {
            String[] v0 = new String[4];
            v0[0] = "null";
            v0[1] = "null";
            v0[v5] = "null";
            v0[v7] = "null";
            String v1 = "/proc/version";
            try {
                BufferedReader v1_2 = new BufferedReader(new FileReader(v1), 8192);
                v0[0] = v1_2.readLine().split("\\s+")[2];
                v1_2.close();
            } catch (IOException v1_1) {
            }

            v0[1] = Build.VERSION.RELEASE;
            v0[v5] = Build.MODEL;
            v0[v7] = Build.DISPLAY;
            android.support.design.a.Z = v0;
        }

        return android.support.design.a.Z;
    }

    private static int F() {
        int v1 = -1;
        try {
            Class v0_1 = Class.forName("android.os.Process");
            if (v0_1 == null) {
                return v1;
            }

            Method v0_2 = android.support.design.a.b(v0_1, "myUserHandle", new Class[0]);
            if (v0_2 != null) {
                int v0_3 = ((Integer) android.support.design.a.b(v0_2.invoke(null), "getIdentifier")).intValue();
                return v0_3;
            }

            v0_1 = Class.forName("android.os.UserId");
            if (v0_1 == null) {
                return v1;
            }

            v0_2 = android.support.design.a.b(v0_1, "getUserId", new Class[]{Integer.TYPE});
            if (v0_2 == null) {
                return v1;
            }

            Object v0_4 = v0_2.invoke(null, Integer.valueOf(Process.myUid()));
            if (v0_4 == null) {
                return v1;
            }

            return ((Integer) v0_4).intValue();
        } catch (Exception v0) {
        }

        return v1;
    }

    private static String F(Context arg2) {
        try {
            if (arg2.getContentResolver() == null) {
                return "";
            }

            if (TextUtils.isEmpty(Settings.Secure.getString(arg2.getContentResolver(), "android_id"))) {
                return "";
            }

            String v0_1 = Settings.Secure.getString(arg2.getContentResolver(), "android_id");
            return v0_1;
        } catch (Exception v0) {
        }

        return "";
    }

    public static boolean F(String arg1) {
        boolean v0 = (arg1.equals("POST")) || (arg1.equals("PATCH")) || (arg1.equals("PUT")) || (arg1.equals("DELETE")) || (arg1.equals("MOVE")) ? true : false;
        return v0;
    }

    public static boolean G(String arg1) {
        boolean v0 = (arg1.equals("POST")) || (arg1.equals("PUT")) || (arg1.equals("PATCH")) || (arg1.equals("PROPPATCH")) || (arg1.equals("REPORT")) ? true : false;
        return v0;
    }

    public static boolean H(String arg1) {
        boolean v0 = (android.support.design.a.G(arg1)) || (arg1.equals("OPTIONS")) || (arg1.equals("DELETE")) || (arg1.equals("PROPFIND")) || (arg1.equals("MKCOL")) || (arg1.equals("LOCK")) ? true : false;
        return v0;
    }

    public static String I(String arg2) {
        String v0 = com.bytedance.ttnet.cc.a().e();
        if (arg2 == null || (TextUtils.isEmpty(((CharSequence) v0)))) {
            v0 = ".snssdk.com";
        }

        return arg2 + v0;
    }

    private static Signature[] K(String arg7) {
        Object v0_5;
        String v0 = "android.content.pm.PackageParser";
        try {
            Class v2 = Class.forName(v0);
            Class[] v0_2 = new Class[]{String.class};
            Object[] v1 = new Object[]{arg7};
            Object v1_1 = Build.VERSION.SDK_INT > 19 ? v2.newInstance() : v2.getConstructor(v0_2).newInstance(v1);
            DisplayMetrics v0_3 = new DisplayMetrics();
            v0_3.setToDefaults();
            if (Build.VERSION.SDK_INT > 19) {
                Method v0_4 = v2.getDeclaredMethod("parsePackage", File.class, Integer.TYPE);
                v0_4.setAccessible(true);
                v0_5 = v0_4.invoke(v1_1, new File(arg7), Integer.valueOf(64));
            } else {
                Method v3 = v2.getDeclaredMethod("parsePackage", File.class, String.class, DisplayMetrics.class, Integer.TYPE);
                v3.setAccessible(true);
                v0_5 = v3.invoke(v1_1, new File(arg7), arg7, v0_3, Integer.valueOf(64));
            }

            v2.getDeclaredMethod("collectCertificates", v0_5.getClass(), Integer.TYPE).invoke(v1_1, v0_5, Integer.valueOf(64));
            v0_5 = v0_5.getClass().getDeclaredField("mSignatures").get(v0_5);
        } catch (Throwable v0_1) {
            v0_1.printStackTrace();
            v0_5 = null;
        }

        return ((Signature[]) v0_5);
    }

    private static String L(String arg6) throws IOException {
        int v0_1;
        long v2;
        RandomAccessFile v1 = new RandomAccessFile(arg6, "r");
        try {
            v2 = v1.length() - 2;
            v1.seek(v2);
            v0_1 = v1.read() & 255 | (v1.read() & 255) << 8;
            if (v0_1 == 0) {
            } else {
                label_17:
                v2 -= ((long) v0_1);
                v1.seek(v2);
                byte[] v2_1 = new byte[v0_1];
                v1.read(v2_1);
                String v0_2 = new String(v2_1);
                return v0_2;
            }
        } finally {
            try {
                v1.close();
            } catch (Exception e) {

            }
        }
        String v0_2 = null;
        return v0_2;

    }

    private static String M(String arg6) {
        try {
            byte[] v1 = MessageDigest.getInstance("SHA1").digest(arg6.getBytes());
            StringBuilder v2 = new StringBuilder();
            int v3 = v1.length;
            int v0_1;
            for (v0_1 = 0; v0_1 < v3; ++v0_1) {
                v2.append(Integer.toString((v1[v0_1] & 255) + 256, 16).substring(1));
            }

            arg6 = v2.toString();
        } catch (NoSuchAlgorithmException v0) {
            v0.printStackTrace();
        }

        return arg6;
    }

    public static void a(Activity arg5) {
        if (arg5 != null) {
            f v2 = new f(arg5.getApplicationContext());
            v2.b = com.ss.android.account.bb.a().b();
            Object v1 = v2.a != null ? v2.a.get() : null;
            if (v1 == null) {
                Logger.w("Starter", "Context is null, could not start");
                return;
            }

            int v0 = 0;
            Intent v3 = new Intent();
            if (v2.b != null) {
                v0 = 1;
                v3.setClass(((Context) v1), v2.b);
            }

            if (v0 == 0) {
                Logger.w("Starter", "lack parameter, could not construct intent");
                return;
            }

            if (!v2.c.isEmpty()) {
                v3.putExtras(v2.c);
            }

            if (v2.a == null) {
                return;
            }

            if (v2.a.get() == null) {
                return;
            }

            v3.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            ((Context) v2.a.get()).startActivity(v3);
        }
    }

    public static void a(Context arg6, String arg7, Drawable arg8, int arg9) {
        int v5 = 17;
        int v1 = 0;
        if (arg6 != null) {
            Context context = arg6.getApplicationContext();
            if (!DeviceUtils.isMiui()
                    && !DeviceUtils.isFlyme()
                    && (SuperToast.a(context))) {
                if (X != null) {
                    SuperToast v2 = X;
                    v2.mHandler.removeMessages(0);
                    v2.mHandler.removeMessages(1);
                    if (v2.b != null && v2.b.getParent() != null) {
                        v2.e.removeView(v2.b);
                    }
                }

                SuperToast v0_1 = SuperToast.makeText(context, arg7, arg9);
                X = v0_1;
                v0_1.d = v5;
                v0_1 = X;
                if (v0_1.b == null) {
                    throw new RuntimeException("This Toast was not created with Toast.makeText()");
                }

                View v0_2 = v0_1.b.findViewById(com.ss.android.article.browser.R.id.icon);
                if (v0_2 == null) {
                    throw new RuntimeException("This Toast was not created with Toast.makeText()");
                }

                ((ImageView) v0_2).setImageDrawable(arg8);
                if (arg8 == null) {
                    v1 = 8;
                }

                ((ImageView) v0_2).setVisibility(v1);
                v0_1 = X;
                if (v0_1.b == null) {
                    throw new RuntimeException("setView must have been called");
                }

                v0_1.mHandler.sendEmptyMessage(1);
                return;
            }

            Toast toast = Toast.makeText(context, arg7, arg9);
            toast.setGravity(v5, 0, 0);
            toast.show();
        }
    }

    public static void resizeDialog(Context context, Dialog dialog) {
        int width = android.support.design.a.dp2px(context, com.ss.android.article.browser.R.dimen.expected_dialog_width);
        int marginHorizontal = android.support.design.a.dp2px(context, com.ss.android.article.browser.R.dimen.expected_dialog_horizontal_margin);
        int screenWidth = UIUtils.getScreenWidth(context);
        if (width > screenWidth - marginHorizontal * 2) {
            width = screenWidth - marginHorizontal * 2;
        }

        Window window = dialog.getWindow();
        if (window != null) {
            window.setLayout(width, ViewGroup.LayoutParams.WRAP_CONTENT);
        }
    }

    public static Object a(Class arg3) {
        Object v0 = null;
        try {
            Class clazz = Class.forName(arg3.getCanonicalName() + "$$Impl");
            if (clazz == null) {
                return v0;
            }

            v0 = clazz.newInstance();
        } catch (IllegalAccessException v1) {
            v1.printStackTrace();
        } catch (InstantiationException v1_1) {
            v1_1.printStackTrace();
        } catch (ClassNotFoundException v1_2) {
            v1_2.printStackTrace();
        }

        return v0;
    }

    public static void onEvent(String arg9, Bundle arg10) {
        long v4 = 0;
        if (!isTextEmpty(arg9)) {
            JSONObject v8 = new JSONObject();
            try {
                v8.put("_event_v3", 1);
                Iterator v1 = arg10.keySet().iterator();
                while (v1.hasNext()) {
                    Object v0_1 = v1.next();
                    v8.put(((String) v0_1), arg10.get(((String) v0_1)));
                }
            } catch (Throwable v0) {
                v0.printStackTrace();
            }

            AppLog.onEvent("event_v3", arg9, null, v4, v4, v8);
        }
    }

    public static Drawable a(Drawable arg1, int arg2) {
        Drawable v0_1;
        try {
            v0_1 = DrawableCompat.wrap(arg1);
            DrawableCompat.setTint(v0_1, arg2);
        } catch (Throwable v0) {
            Logger.throwExceptionInDebug(v0);
            v0_1 = null;
        }

        return v0_1;
    }


    public static void a(Context arg2, IBinder arg3) {
        try {
            ((InputMethodManager) arg2.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(arg3, 0);
        } catch (Exception v0) {
        }
    }

    public static void a(Context arg2, View arg3) {
        try {
            ((InputMethodManager) arg2.getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(arg3, 0);
        } catch (Exception v0) {
        }
    }

    public static boolean hasVideo(Article article) {
        return article != null
                && android.support.design.a.b(((long) article.groupFlags))
                && article.hasVideo();
    }

    public static NoNetView a(Context arg6, View arg7, ac arg8, ad arg9, ab arg10) {
        return android.support.design.a.a(arg6, arg7, arg8, arg9, arg10, false);
    }

    public static long a(String arg8, String arg9, boolean arg10, Context arg11, String arg12, List arg13, boolean arg14) {
        String v1_2;
        DownloadManager.Request request;
        String v4;
        Uri v1;
        Object v0_2;
        long v0;
        long v2 = -1;
        if (arg11 == null) {
            v0 = v2;
            return v0;
        }

        try {
            v0_2 = arg11.getSystemService(Context.DOWNLOAD_SERVICE);
            if (v0_2 != null) {
                try {
                    label_12:
                    v1 = Uri.parse(arg8);
                    v4 = v1.getLastPathSegment();
                    if (isTextEmpty(v4)) {
                        if (!isTextEmpty(arg9)) {
                            v4 = arg9;
                        } else {
                            label_43:
                            if (arg10) {
                                v4 = "default.apk";
                            } else {
                                return v2;
                            }
                        }
                    }

                    if (isTextEmpty(arg9)) {
                        arg9 = v4;
                    }
                    request = new DownloadManager.Request(v1);
                    if (arg13 != null) {
                        Iterator v6 = arg13.iterator();
                        while (v6.hasNext()) {
                            Object v1_1 = v6.next();
                            request.addRequestHeader(((HttpHeader) v1_1).name(), ((HttpHeader) v1_1).value());
                        }
                    }

                    new com.ss.android.newmedia.download.b((byte) 0);
                    request.setNotificationVisibility(1);
                    if (!arg10) {
                        v1_2 = v4;
                    } else if (!v4.endsWith(".apk")) {
                        v1_2 = v4 + ".apk";
                    } else {
                        v1_2 = v4;
                    }
                    if ((arg10) || (v1_2.endsWith(".apk"))) {
                        arg12 = "application/vnd.android.package-archive";
                    }

                    if (!isTextEmpty(arg12)) {
                        request.setMimeType(arg12);
                    }

                    request.setTitle(((CharSequence) arg9));
                    File v4_1 = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
                    if (v4_1 != null && !v4_1.exists() && !v4_1.mkdirs()) {
                        return v2;
                    }

                    request.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, v1_2);
                    request.setAllowedOverRoaming(false);
                    v0 = ((DownloadManager) v0_2).enqueue(request);
                    if (!arg14) {
                        return v0;
                    }
                    UIUtils.showImageToast(arg11, com.ss.android.article.browser.R.drawable.doneicon_popup_textpage, com.ss.android.article.browser.R.string.toast_download_app);
                } catch (Throwable throwable) {
                    Logger.d("MyDownloadManager", "add download task error:" + throwable);
                    v0 = v2;
                }

                return v0;
            }
        } catch (Exception v0_1) {
            return v2;
        }
        return v2;


    }

    public static void showImageToast(Context context, int stringResId, int drawableResId) {
        if (context != null) {
            String text = stringResId > 0 ? context.getString(stringResId) : "";
            Drawable drawable = drawableResId > 0 ? context.getResources().getDrawable(drawableResId) : null;
            android.support.design.a.showToast(context, text, drawable);
        }
    }

    public static List<Image> imageInfoList2ImageList(List<ImageInfo> imageInfoList) {
        if (imageInfoList == null) {
            return null;
        } else {
            ArrayList<Image> imageList = new ArrayList(imageInfoList.size());
            Iterator<ImageInfo> iterator = imageInfoList.iterator();
            while (iterator.hasNext()) {
                Image image = android.support.design.a.imageInfo2Image(iterator.next());
                if (image == null) {
                    continue;
                }

                imageList.add(image);
            }
            return imageList;
        }
    }

    public static String doGetNetworkAccessType(NetworkType arg3) {
        String v0 = "";
        try {
            switch (com.bytedance.common.utility.f.a[arg3.ordinal()]) {
                case 1: {
                    return "wifi";
                }
                case 2: {
                    return "2g";
                }
                case 3: {
                    return "3g";
                }
                case 4: {
                    return "4g";
                }
                case 5: {
                    return "mobile";
                }
            }

            return v0;
        } catch (Exception v1) {
        }

        return v0;
    }

    public static boolean a(Context arg2) {
        NetworkType v0 = android.support.design.a.getNetworkType(arg2);
        boolean v0_1 = v0 == NetworkType.MOBILE || v0 == NetworkType.MOBILE_2G ? true : false;
        return v0_1;
    }

    public static int a(int arg0, int arg1, int arg2) {
        if (arg0 >= arg1) {
            arg1 = arg0 > arg2 ? arg2 : arg0;
        }

        return arg1;
    }

    public static int a(int arg4, Context arg5) {
        int v0;
        int v1 = -1;
        if (arg5 == null) {
            v0 = v1;
            return v0;
        }

        try {
            Debug.MemoryInfo[] v0_2 = ((ActivityManager) arg5.getSystemService(Context.ACTIVITY_SERVICE)).getProcessMemoryInfo(new int[]{arg4});
            v0_2[0].getTotalSharedDirty();
            v0 = v0_2[0].dalvikPss;
        } catch (Exception v0_1) {
            v0_1.printStackTrace();
            v0 = v1;
        }

        return v0;
    }

    public static int a(int arg2, Object arg3) {
        int v0 = arg3 != null ? arg3.hashCode() : 0;
        return v0 + arg2 * 37;
    }

    public static int a(Context arg5, String arg6) {
        int v0_1;
        int v1 = -1;
        int v3 = Process.myPid();
        int v4 = Process.myUid();
        String v0 = arg5.getPackageName();
        if (arg5.checkPermission(arg6, v3, v4) == PackageManager.PERMISSION_DENIED) {
            v0_1 = v1;
        } else {
            String v3_1 = AppOpsManagerCompat.permissionToOp(arg6);
            if (v3_1 != null) {
                if (v0 == null) {
                    String[] v0_2 = arg5.getPackageManager().getPackagesForUid(v4);
                    if (v0_2 != null && v0_2.length > 0) {
                        v0 = v0_2[0];
                    } else {
                        return v1;
                    }
                }

                if (AppOpsManagerCompat.noteProxyOp(arg5, v3_1, v0) == 0) {
                    return 0;
                }

                return -2;
            }

            v0_1 = 0;
        }

        return v0_1;
    }

    public static int a(Article article, int arg5) {
        int v0 = 3;
        int v1 = 2;
        if (article == null) {
            v0 = 0;
        } else {
            if (article.largeImageList != null && arg5 == v1) {
                return 4;
            }

            if (article.imageList != null && article.imageList.size() >= v0 && arg5 == 1) {
                return v0;
            }

            if (arg5 == 0) {
                if (article.imageList != null && article.imageList.size() > 0) {
                    return v1;
                }

                if (article.middleImage == null) {
                    return 1;
                }

                return v1;
            }

            v0 = 1;
        }

        return v0;
    }

    public static int a(Comparable arg1, Comparable arg2) {
        int v0;
        if (arg1 == arg2) {
            v0 = 0;
        } else if (arg1 == null) {
            v0 = -1;
        } else if (arg2 == null) {
            v0 = 1;
        } else {
            v0 = arg1.compareTo(arg2);
        }

        return v0;
    }

    public static int a(String arg4, int arg5) {
        int v3 = 6;
        int v2 = 4;
        int v0 = 0;
        if (android.support.design.a.q(arg4)) {
            switch (arg5) {
                case 1:
                    return Integer.valueOf(arg4.substring(0, v2)).intValue();
                case 2:
                    return Integer.valueOf(arg4.substring(v2, v3)).intValue() - 1;
                case 5:
                    return Integer.valueOf(arg4.substring(v3, 8)).intValue();
            }

            return v0;
        }
        return v0;
    }

    public static int a(Throwable arg5, String[] arg6) {
        Matcher v1_3;
        String v1_2;
        int v1 = 2;
        int v0 = 1;
        int v2 = 3;
        int v3 = 4;
        if (arg5 == null) {
            return v0;
        }

        if (arg6 == null) {
            arg6 = new String[1];
        }

        if ((arg5 instanceof HttpResponseException)) {
            v0 = ((HttpResponseException) arg5).getStatusCode();
        } else if ((arg5 instanceof DownloadFileTooLargeException)) {
            v0 = 20;
        } else if ((arg5 instanceof ConnectTimeoutException)) {
            v0 = v1;
        } else if ((arg5 instanceof SocketTimeoutException)) {
            if (!isTextEmpty(arg5.getMessage()) && (arg5.getMessage().contains("connect timed out"))) {
                v0 = v1;
            } else {
                v0 = v2;
            }
        } else {
            if ((arg5 instanceof BindException)) {
                v0 = 7;
            } else if ((arg5 instanceof ConnectException)) {
                v0 = 8;
            } else if ((arg5 instanceof NoRouteToHostException)) {
                v0 = 9;
            } else if ((arg5 instanceof PortUnreachableException)) {
                v0 = 10;
            } else if ((arg5 instanceof SocketException)) {
                v0 = 5;
                String v2_1 = arg5.getMessage();
                if (v2_1 == null) {
                } else if (v2_1.indexOf("reset by peer") < 0) {
                } else {
                    v0 = 6;
                }
            } else if ((arg5 instanceof UnknownHostException)) {
                v0 = 11;
            } else if ((arg5 instanceof NoHttpResponseException)) {
                v0 = 18;
            } else if ((arg5 instanceof ClientProtocolException)) {
                v0 = 19;
            } else if (!(arg5 instanceof IOException)) {
            } else {
                v0 = v3;
            }
        }

        label_12:
        if (v0 == v1) {
            try {
                v1_2 = arg5.getMessage();
                if (Logger.debug()) {
                    Logger.d("AppLog", "SC_CONNECT_TIMEOUT " + v1_2);
                }

                v1_3 = Pattern.compile("Connect to +([\\w\\.\\-]+)?/(\\[([a-zA-Z0-9:]+)\\]|(\\d{1,3}(\\.\\d{1,3}){3,3})):(\\d+) +timed out").matcher(((CharSequence) v1_2));
                if (v1_3.matches()) {
                    if (v1_3.group(3) != null) {
                        arg6[0] = v1_3.group(3);
                    } else {
                        v2 = 4;
                        if (v1_3.group(v2) != null) {
                            arg6[0] = v1_3.group(4);
                        }
                    }
                }

                if (!Logger.debug()) {
                    return v0;
                }
                Logger.d("AppLog", "SC_CONNECT_TIMEOUT ip " + arg6[0]);
            } catch (Exception v1_1) {
            }
            return v0;
        }

        if (v0 == 8) {
            try {
                Throwable v1_4 = arg5.getCause();
                if (v1_4 == null) {
                    return v0;
                }

                if (!(v1_4 instanceof ConnectException)) {
                    return v0;
                }

                v1_2 = v1_4.getMessage();
                if (Logger.debug()) {
                    Logger.d("AppLog", "SC_CONNECT_EXCEPTION " + v1_2);
                }

                Matcher v2_2 = Pattern.compile("failed to connect to +([\\w\\.\\-]+)?/(\\[([a-zA-Z0-9:]+)\\]|(\\d{1,3}(\\.\\d{1,3}){3,3})) \\(port \\d+\\)( +after \\d+ms)?: +\\w+ failed: (E[A-Z]+) .*").matcher(((CharSequence) v1_2));
                v1_2 = null;
                if (v2_2.matches()) {
                    if (v2_2.group(3) != null) {
                        arg6[0] = v2_2.group(3);
                    } else if (v2_2.group(4) != null) {
                        arg6[0] = v2_2.group(4);
                    }

                    v1_2 = v2_2.group(7);
                    if (v1_2 == null) {
                    } else if ("ECONNRESET".equals(v1_2)) {
                        v0 = 12;
                    } else if ("ECONNREFUSED".equals(v1_2)) {
                        v0 = 13;
                    } else if ("EHOSTUNREACH".equals(v1_2)) {
                        v0 = 14;
                    } else if ("ENETUNREACH".equals(v1_2)) {
                        v0 = 15;
                    } else if ("EADDRNOTAVAIL".equals(v1_2)) {
                        v0 = 16;
                    } else if (!"EADDRINUSE".equals(v1_2)) {
                    } else {
                        v0 = 17;
                    }
                }

                if (!Logger.debug()) {
                    return v0;
                }

                Logger.d("AppLog", "SC_CONNECT_EXCEPTION ip " + arg6[0] + " " + v1_2);
                return v0;
            } catch (Exception v1_1) {
                return v0;
            }
        }

        if (v0 != v3) {
            return v0;
        }

        try {
            v1_2 = arg5.getMessage();
            if (v1_2.indexOf(" EIO (I/O error)") > 0) {
                return 37;
            }

            if ((arg5 instanceof FileNotFoundException)) {
                return 33;
            }

            if (v1_2.indexOf(" ENOENT ") <= 0 && v1_2.indexOf("No such file or directory") <= 0) {
                if (v1_2.indexOf(" ENOSPC ") <= 0 && v1_2.indexOf("No space left on device") <= 0) {
                    if (v1_2.indexOf(" EDQUOT ") > 0) {
                        return 34;
                    } else if (v1_2.indexOf(" EROFS ") > 0) {
                        return 35;
                    } else if (v1_2.indexOf(" EACCES ") > 0) {
                        return 36;
                    } else {
                        return v0;
                    }
                }

                return 32;
            }

            return 33;
        } catch (Exception v1_1) {
            return v0;
        }
    }

    public static int a(Field arg3, TextView arg4) {
        int v0_1;
        try {
            v0_1 = arg3.getInt(arg4);
        } catch (IllegalAccessException v0) {
            Log.d("TextViewCompatDonut", "Could not retrieve value of " + arg3.getName() + " field.");
            v0_1 = -1;
        }

        return v0_1;
    }

    public static int a(long[] arg6, int arg7, long arg8) {
        int v0;
        int v2 = arg7 - 1;
        int v1 = 0;
        while (true) {
            if (v1 <= v2) {
                v0 = v1 + v2 >>> 1;
                long v4 = arg6[v0];
                if (v4 < arg8) {
                    v1 = v0 + 1;
                    continue;
                } else if (v4 > arg8) {
                    v2 = v0 - 1;
                    continue;
                }
            } else {
                break;
            }

            return v0;
        }

        return v1 ^ -1;
    }

    public static long a(int arg6) {
        long v0_3;
        try {
            BufferedReader v0_1 = new BufferedReader(new InputStreamReader(new FileInputStream("/proc/" + arg6 + "/stat")), 1000);
            String v1 = v0_1.readLine();
            v0_1.close();
            String[] v0_2 = v1.split(" ");
            v0_3 = Long.parseLong(v0_2[16]) + (Long.parseLong(v0_2[13]) + Long.parseLong(v0_2[14]) + Long.parseLong(v0_2[15]));
        } catch (IOException v0) {
            v0.printStackTrace();
            v0_3 = -1;
        }

        return v0_3;
    }

    public static Notification a(NotificationCompat.Builder arg3, Context arg4, String arg5, String arg6) {
        Bitmap v0 = null;
        try {
            v0 = BitmapFactory.decodeResource(arg4.getResources(), com.ss.android.article.browser.R.drawable.icon);
        } catch (Exception v1) {
        }

        arg3.setContentTitle(arg5)
                .setContentText(arg6)
                .setStyle(new BigTextStyle().bigText(arg6));
        if (v0 != null && !v0.isRecycled()) {
            arg3 = arg3.setLargeIcon(v0);
        }
        return arg3.build();
    }

    public static Notification a(NotificationCompat.Builder arg3, Context arg4, String arg5, String arg6, Bitmap arg7) {
        Bitmap v0 = null;
        try {
            v0 = BitmapFactory.decodeResource(arg4.getResources(), com.ss.android.article.browser.R.drawable.icon);
        } catch (Exception v1) {
        }

        BigPictureStyle v1_1 = new BigPictureStyle().bigPicture(arg7).setSummaryText(arg6)
                .setBigContentTitle(arg5);
        BigPictureStyle v0_1 = v0 == null || (v0.isRecycled()) ? v1_1 : v1_1.bigLargeIcon(v0);
        arg3.setContentTitle(arg5).setContentText(arg6).setStyle(v0_1).setLargeIcon(arg7);
        return arg3.build();
    }

    public static Notification buildNotification(NotificationCompat.Builder builder, String contentTitle, String contentInfo, int progress) {
        builder.setContentTitle(contentTitle).setContentInfo(contentInfo).setProgress(100, progress, false);
        return builder.build();
    }

    public static Bitmap a(Bitmap arg7, int arg8) {
        if (arg7 != null) {
            Matrix v5 = new Matrix();
            v5.postRotate(((float) arg8));
            arg7 = Bitmap.createBitmap(arg7, 0, 0, arg7.getWidth(), arg7.getHeight(), v5, true);
        }

        return arg7;
    }

    private static Bitmap decodeFile(File file, int expectedWidth, int expectedHeight, Bitmap.Config bitmapConfig) {
        if (expectedWidth > 0 && expectedHeight > 0) {
            try {
                if (!file.isFile()) {
                    return null;
                }
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inJustDecodeBounds = true;
                FileInputStream fileInputStream = new FileInputStream(file);
                BitmapFactory.decodeStream(fileInputStream, null, options);
                fileInputStream.close();
                int outWidth = options.outWidth;
                int outHeight = options.outHeight;
                int inSampleSize = 1;
                FileInputStream fis;
                while (outWidth / 2 >= expectedWidth || outHeight / 2 >= expectedHeight) {
                    outWidth /= 2;
                    outHeight /= 2;
                    inSampleSize <<= 1;
                }
                options = new BitmapFactory.Options();
                options.inSampleSize = inSampleSize;
                options.inPurgeable = true;
                options.inPreferredConfig = bitmapConfig != null ? bitmapConfig : Bitmap.Config.RGB_565;
                fis = new FileInputStream(file);
                Bitmap bitmap = BitmapFactory.decodeStream(fis, null, options);
                fis.close();
                return bitmap;
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
        }
        return null;
    }

    private static Bitmap a(File arg5, int arg6, boolean arg7) {
        int v1 = 1;
        Bitmap v0 = null;
        try {
            BitmapFactory.Options v2 = new BitmapFactory.Options();
            v2.inJustDecodeBounds = true;
            FileInputStream v3 = new FileInputStream(arg5);
            BitmapFactory.decodeStream(((InputStream) v3), null, v2);
            v3.close();
            if (v2.outWidth <= 0 || v2.outHeight <= 0) {
                arg5.delete();
                return v0;
            }

            while (v2.outWidth >= arg6 << 1) {
                if (v2.outHeight < 4000) {
                    break;
                }

                v2.outWidth /= 2;
                v2.outHeight /= 2;
                v1 <<= 1;
            }

            v2 = new BitmapFactory.Options();
            v2.inSampleSize = v1;
            v2.inPurgeable = true;
            Bitmap.Config v1_2 = arg7 ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565;
            v2.inPreferredConfig = v1_2;
            FileInputStream v1_3 = new FileInputStream(arg5);
            v0 = BitmapFactory.decodeStream(((InputStream) v1_3), null, v2);
            v1_3.close();
            if (v0 == null) {
                arg5.delete();
            }

            return v0;
        } catch (Exception v1_1) {
            return v0;
        }
    }

    public static Bitmap decodeFile(String path, int expectWidth, int expectHeight, Bitmap.Config bitmapConfig) {
        try {
            File file = new File(path);
            if (file.isFile()) {
                file.setLastModified(System.currentTimeMillis());
                return decodeFile(file, expectWidth, expectHeight, bitmapConfig);
            }
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static Bitmap a(String arg4, int arg5, boolean arg6) {
        Bitmap v0 = null;
        File v1 = new File(arg4);
        if (v1.exists()) {
            try {
                v1.setLastModified(System.currentTimeMillis());
            } catch (Exception v2) {
            }

            try {
                v0 = a(v1, arg5, arg6);
            } catch (Exception v1_1) {
                v1_1.printStackTrace();
            }
        }

        return v0;
    }

    public static ArrayMap a(JSONObject arg5) {
        ArrayMap v1 = new ArrayMap();
        try {
            JSONObject v2 = arg5.optJSONObject("app_list");
            if (v2 == null) {
                return v1;
            }

            Iterator v3 = v2.keys();
            while (v3.hasNext()) {
                Object v0_1 = v3.next();
                v1.put(v0_1, Integer.valueOf(v2.getInt(((String) v0_1))));
            }

            ArrayMap v0_2 = v1;
            return v0_2;
        } catch (Exception v0) {
            v0.printStackTrace();
        }

        return v1;
    }

    public static Pair a(com.ss.android.lockscreen.views.ratio.b arg4, int arg5, int arg6) {
        Pair v0;
        if (arg4 == null) {
            v0 = new Pair(Integer.valueOf(arg5), Integer.valueOf(arg6));
        } else {
            float v0_1 = (((float) arg4.c)) / (((float) arg4.b));
            if (arg4.a == 0) {
                arg5 = View.MeasureSpec.makeMeasureSpec(Math.round(v0_1 * (((float) View.MeasureSpec.getSize(arg6)))), View.MeasureSpec.EXACTLY);
            } else if (arg4.a == 1) {
                arg6 = View.MeasureSpec.makeMeasureSpec(Math.round((((float) View.MeasureSpec.getSize(arg5))) / v0_1), View.MeasureSpec.EXACTLY);
            }

            v0 = new Pair(Integer.valueOf(arg5), Integer.valueOf(arg6));
        }

        return v0;
    }

    public static View a(ViewGroup arg4, int arg5) {
        View v0;
        int childCount = arg4.getChildCount();
        int v1 = 0;
        while (true) {
            if (v1 < childCount) {
                v0 = arg4.getChildAt(v1);
                if (v0.getId() != arg5) {
                    ++v1;
                    continue;
                }
            } else {
                return null;
            }

            return v0;
        }
    }

    public static Interpolator a(float arg2, float arg3, float arg4) {
        return PathInterpolatorCompat.create(arg2, arg3, arg4, 1f);
    }

    public static JsonElement a(com.google.gson.stream.JsonReader arg2) throws JsonParseException {
        Object v0_4;
        try {
            arg2.peek();
            v0_4 = TypeAdapters.BIT_SET.read(arg2);
        } catch (EOFException v0) {
            throw new JsonSyntaxException(((Throwable) v0));
        } catch (MalformedJsonException v0_1) {
            throw new JsonSyntaxException(((Throwable) v0_1));
        } catch (IOException v0_2) {
            throw new JsonIOException(((Throwable) v0_2));
        } catch (NumberFormatException v0_3) {
            throw new JsonSyntaxException(((Throwable) v0_3));
        }
        return ((JsonElement) v0_4);
    }

    public static NoNetView a(Context arg4, View arg5, ac arg6, ad arg7, ab arg8, boolean arg9) {
        int v1 = -1;
        int v0 = -2;
        NoNetView v3 = new NoNetView(arg4);
        v3.setButtonOption(arg8);
        v3.setImgOption(arg6);
        v3.setTextOption(arg7);
        if (arg5 != null) {
            if ((arg5 instanceof RelativeLayout)) {
                int v2 = arg9 ? v0 : v1;
                if (!arg9) {
                    v0 = v1;
                }

                RelativeLayout.LayoutParams v1_1 = new RelativeLayout.LayoutParams(v2, v0);
                v0 = arg9 ? 13 : 14;
                v1_1.addRule(v0);
                ((RelativeLayout) arg5).addView(v3, v1_1);
            } else {
                if ((arg5 instanceof LinearLayout)) {
                    ((LinearLayout) arg5).addView(v3);
                    ViewGroup.LayoutParams v0_1 = v3.getLayoutParams();
                    v1 = arg9 ? 17 : 1;
                    ((LinearLayout.LayoutParams) v0_1).gravity = v1;
                    v3.setLayoutParams(v0_1);
                } else if (!(arg5 instanceof FrameLayout)) {
                } else {
                    ((FrameLayout) arg5).addView(v3, 0);
                }
            }
        }
        v3.setVisibility(View.GONE);
        return v3;
    }

    public static ShareData a(ShareEntity arg2) {
        ShareData v0;
        if (arg2 == null) {
            v0 = null;
        } else {
            v0 = new ShareData();
            v0.mContent = arg2.content;
            v0.mTitle = arg2.title;
            v0.mImageUrl = arg2.image_url;
            v0.mShareUrl = arg2.share_url;
        }

        return v0;
    }

    public static Image imageInfo2Image(ImageInfo imageInfo) {
        Image image;
        if (imageInfo == null) {
            image = null;
        } else if (imageInfo.mImage != null) {
            image = imageInfo.mImage;
        } else {
            image = ImageInfo.createImage(imageInfo);
            imageInfo.mImage = image;
        }
        return image;
    }

    public static com.ss.android.lockscreen.views.ratio.b a(Context arg5, AttributeSet arg6) {
        com.ss.android.lockscreen.views.ratio.b v0;
        TypedArray v1 = arg5.obtainStyledAttributes(arg6, com.ss.android.lockscreen.f.a);
        String v2 = v1.getString(com.ss.android.lockscreen.f.d);
        String v3 = v1.getString(com.ss.android.lockscreen.f.c);
        String v4 = v1.getString(com.ss.android.lockscreen.f.b);
        if (v2 == null || v3 == null) {
            v1.recycle();
            v0 = null;
        } else {
            v0 = new com.ss.android.lockscreen.views.ratio.b();
            v0.c = Integer.parseInt(v2);
            v0.b = Integer.parseInt(v3);
            if (v4 != null) {
                v0.a = Integer.parseInt(v4);
            }

            v1.recycle();
        }

        return v0;
    }

    public static User a(UserEntity arg2) {
        User v0;
        if (arg2 == null) {
            v0 = null;
        } else {
            v0 = new User(arg2.user_id);
            v0.mUserName = arg2.uname;
            v0.mAvatarUrl = arg2.avatar_url;
            v0.mUserIntro = arg2.user_intro;
            v0.mIsVerify = arg2.is_verify;
        }

        return v0;
    }

    public static FileInputStream a(File arg4) {
        FileInputStream v0_1;
        FileInputStream v1 = null;
        try {
            v0_1 = new FileInputStream(arg4);
        } catch (FileNotFoundException v0) {
            Logger.e("FileUtils", "catch", ((Throwable) v0));
            v0_1 = v1;
        }

        return v0_1;
    }

    public static Writer a(Appendable arg0) {
        return (Writer) arg0;
    }

    public static CharSequence a(String arg6, List arg7, int arg8) {
        CharSequence v6 = null;
        if (!isTextEmpty(arg6) && arg7 != null && !arg7.isEmpty()) {
            SpannableString v1 = new SpannableString(arg6);
            Iterator v2 = arg7.iterator();
            while (v2.hasNext()) {
                Object v0 = v2.next();
                if (isTextEmpty(((String) v0))) {
                    continue;
                }

                int v3 = arg6.indexOf(((String) v0));
                if (v3 < 0) {
                    continue;
                }

                v1.setSpan(new ForegroundColorSpan(arg8), v3, ((String) v0).length() + v3, 17);
            }

            v6 = v1;
        }

        return v6;
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public static Object a(int arg9, long arg10, long arg12, float arg14, long arg15, CharSequence arg17, long arg18, List arg20, long arg21) {
        PlaybackState.Builder v2 = new PlaybackState.Builder();
        v2.setState(arg9, arg10, arg14, arg18);
        v2.setBufferedPosition(arg12);
        v2.setActions(arg15);
        v2.setErrorMessage(arg17);
        Iterator v4 = arg20.iterator();
        while (v4.hasNext()) {
            v2.addCustomAction((PlaybackState.CustomAction) v4.next());
        }

        v2.setActiveQueueItemId(arg21);
        return v2.build();
    }

    public static Object a(Class arg5, String arg6, Class[] arg7, Object[] arg8, Object[] arg9) {
        Object v0 = null;
        if (arg5 != null && !isTextEmpty(arg6)) {
            if (arg7 == null) {
                arg7 = new Class[0];
            }

            if (arg8 == null) {
                arg8 = new Object[0];
            }

            try {
                Method v1_1 = a(arg5, arg6, arg7);
                if (v1_1 == null) {
                    return v0;
                }

                v1_1.setAccessible(true);
                if (arg9 != null && arg9.length > 0) {
                    return v1_1.invoke(arg9[0], arg8);
                }

                v0 = v1_1.invoke(null, arg8);
            } catch (Throwable v1) {
                Logger.e("ReflectUtils", "exception in invokeMethod, pkg : " + arg5.getName() + ", function : " + arg6 + ", " + v1.toString());
            }
        }

        return v0;
    }

    private static Method a(Class arg5, String arg6, Class[] arg7) {
        Method v0 = null;
        if (arg5 != null && !isTextEmpty(arg6)) {
            try {
                Logger.d("ReflectUtils", "thread id : " + Thread.currentThread().getName());
                v0 = arg5.getMethod(arg6, arg7);
            } catch (Throwable v1) {
                Logger.e("ReflectUtils", "exception in getMethod, pkg : " + arg5.getName() + ", function : " + arg6 + ", " + v1.toString());
                try {
                    v0 = arg5.getDeclaredMethod(arg6, arg7);
                } catch (Throwable v2) {
                }
            }
        }

        return v0;
    }

    public static Object a(Class arg1, String arg2, Object[] arg3) {
        return a(arg1, arg2, null, null, arg3);
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public static Object a(Object arg0) {
        Transition v0;
        if (arg0 != null) {
            arg0 = ((Transition) arg0).clone();
        }

        return arg0;
    }

    private static Object a(Object arg3, String arg4, Class[] arg5, Object[] arg6) {
        Method v0 = b(arg3, arg4, arg5);
        v0.setAccessible(true);
        if (v0 != null) {
            try {
                Object v0_4 = v0.invoke(arg3, arg6);
                return v0_4;
            } catch (InvocationTargetException v0_1) {
                Throwable v1 = v0_1.getTargetException();
                if (v1 != null) {
                    System.out.print(v1.getMessage());
                }

                v0_1.printStackTrace();
            } catch (IllegalAccessException v0_2) {
                v0_2.printStackTrace();
            } catch (IllegalArgumentException v0_3) {
                v0_3.printStackTrace();
            }
        }

        return null;
    }

    public static String a(long arg10) {
        String v0;
        long v8 = 1;
        int v5 = 4;
        int v1 = 0;
        int v7 = 5;
        long[] v2 = new long[]{1099511627776L, 1073741824, 1048576, 1024, 1};
        String[] v3 = new String[v7];
        v3[0] = "TB";
        v3[1] = "GB";
        v3[2] = "MB";
        v3[3] = "KB";
        v3[v5] = "B";
        if (arg10 < v8) {
            v0 = "0 " + v3[v5];
        } else {
            v0 = null;
            while (v1 < v7) {
                long v4 = v2[v1];
                if (arg10 >= v4) {
                    String v2_1 = v3[v1];
                    double v0_1 = v4 > v8 ? (((double) arg10)) / (((double) v4)) : ((double) arg10);
                    v0 = new DecimalFormat("#.##").format(v0_1) + " " + v2_1;
                } else {
                    ++v1;
                    continue;
                }

                return v0;
            }
        }

        return v0;
    }

    public static String a(long arg2, long arg4, String arg6) {
        StringBuilder v0 = new StringBuilder();
        v0.append(arg2);
        v0.append("_");
        v0.append(arg4);
        if (!isTextEmpty(arg6)) {
            v0.append("_");
            v0.append(arg6);
        }

        return v0.toString();
    }

    public static String a(Context arg3, int arg4) {
        String v0_1;
        try {
            v0_1 = "";
            switch (arg4) {
                case 1: {
                    label_6:
                    v0_1 = com.bytedance.ttnet.cc.a().b(arg3, "ssids", "");
                    break;
                }
                case 2: {
                    label_11:
                    v0_1 = com.bytedance.ttnet.cc.a().b(arg3, "dns", "");
                    break;
                }
                case 3: {
                    label_16:
                    v0_1 = com.bytedance.ttnet.cc.a().b(arg3, "https_dns", "");
                    break;
                }
            }
        } catch (Exception v0) {
            v0_1 = "";
        }

        return (v0_1 instanceof String) ? String.valueOf(v0_1) : "";
    }

    public static String a(Context context, String path, StringBuilder arg8) {
        FileInputStream v2 = null;
        String v0 = null;
        if (context == null && path == null) {
            arg8.append("context or path is null.\r\n");
            return v0;
        }

        File v1 = new File(path);
        if (!v1.exists()) {
            arg8.append("file not exist.path:").append(path).append("\r\n");
            return v0;
        }

        if (v1.length() == 0) {
            arg8.append("file size is zore.\r\n");
            return v0;
        }

        ByteArrayOutputStream v3 = new ByteArrayOutputStream();
        try {
            v2 = new FileInputStream(v1);
            b(((InputStream) v2), ((OutputStream) v3));
            v2.close();
            String v1_2 = Base64.encodeToString(v3.toByteArray(), 0);
            return v1_2;
        } catch (Exception v1_1) {
            v1_1.printStackTrace();
            arg8.append("gzip file is error.error:").append(v1_1.getMessage());
            return v0;
        } finally {
            if (v2 != null) {
                try {
                    v2.close();
                } catch (IOException v2_1) {
                    v2_1.printStackTrace();
                }
            }

            if (v3 != null) {
                try {
                    v3.close();
                } catch (IOException v2_1) {
                }
            }
        }
    }

    public static String getColumnValue(Cursor arg2, String arg3) {
        String v0 = "";
        if (arg2 != null) {
            int v1 = arg2.getColumnIndex(arg3);
            if (v1 >= 0) {
                String v1_1 = arg2.getString(v1);
                if (v1_1 != null) {
                    v0 = v1_1;
                }
            }
        }

        return v0;
    }

    @NotNull
    public static String a(File arg3, File arg4, String arg5) {
        StringBuilder sb = new StringBuilder(arg3.toString());
        if (arg4 != null) {
            sb.append(" -> " + arg4);
        }

        if (arg5 != null) {
            sb.append(": " + arg5);
        }

        return sb.toString();
    }

    public static String a(String arg10, GetDomainContext arg11) throws Throwable {
        URLConnection v2_1;
        String v3_1;
        Object v1_3;
        boolean v6;
        InputStream v5;
        int v1_2;
        URLConnection conn = null;
        String v1;
        String v4;
        String v2 = null;
        if (isTextEmpty(arg10)) {
            String v0 = v2;
            return v0;
        }

        if (!isNetworkAvailable(com.bytedance.ttnet.cc.a().getContext())) {
            return v2;
        }
        try {
            v4 = AppConfig.d(arg10);
            v1 = "GET";
            conn = new URL(v4).openConnection();
            ((HttpURLConnection) conn).setRequestMethod(v1);

            ((HttpURLConnection) conn).setConnectTimeout(AppConfig.getConnectTimeout());
            ((HttpURLConnection) conn).setReadTimeout(AppConfig.getReadWriteTimeout());
            ((HttpURLConnection) conn).setInstanceFollowRedirects(true);
            ((HttpURLConnection) conn).setRequestProperty("Accept-Encoding", "gzip");
            v1 = arg11.useHttps ? " HttpsURLConnection" : " HttpURLConnection";
            ((HttpURLConnection) conn).setRequestProperty("User-Agent", AppConfig.getUserAgent() + v1);
            v1_2 = ((HttpURLConnection) conn).getResponseCode();
            arg11.status = v1_2;
            if (!arg11.useHttps) {
                arg11.rawSign = ((HttpURLConnection) conn).getHeaderField("X-SS-SIGN");
            }

            if (v1_2 != 200) {
                throw new IOException("err status = " + v1_2);
            }

            v5 = ((HttpURLConnection) conn).getInputStream();
            v6 = "gzip".equals(((HttpURLConnection) conn).getHeaderField("Content-Encoding"));
            v1 = ((HttpURLConnection) conn).getHeaderField("Content-Type");
            boolean v7 = hasSSMix(v1);
            Pair<String, String> v3 = RetrofitUtils.a(v1);
            if (v3 == null) {
                v1_3 = v2;
            } else if (v3.second == null) {
                v1_3 = v2;
            } else if (Charset.isSupported(v3.second)) {
                v1_3 = v3.second;
            } else {
                v1_3 = v2;
            }
            label_62:
            if (v1_3 == null) {
                v3_1 = "UTF-8";
            } else {
                v3_1 = (String) v1_3;
            }

            int[] v8 = new int[]{0};
            byte[] v4_1 = a(v6, v5, v8, new com.bytedance.ttnet.b.d(v4, ((HttpURLConnection) conn)));
            if (v4_1 != null && v8[0] > 0 && v8[0] <= v4_1.length) {
                if (v7) {
                    decodeBytes(v4_1, v8[0]);
                }
                v1 = new String(v4_1, 0, v8[0], v3_1);
                return v1;
            }

            return v2;
        } catch (Throwable v1_1) {
            v1_1.printStackTrace();
            return v2;
        } finally {
            try {
                if (conn != null) {
                    ((HttpURLConnection) conn).disconnect();
                }
            } catch (Exception v0_3) {
            }
        }
    }

    private static byte[] a(boolean arg3, InputStream arg4, int[] arg5, com.bytedance.frameworks.baselib.network.http.f arg6) throws IOException {
        byte[] v1_1;
        byte[] v0 = null;
        if (arg4 != null) {
            int v1 = -1;
            try {
                v1_1 = unzipStream(arg3, v1, arg4, arg5);
                if (v1_1 == null) {
                    return v0;
                }
            } catch (Exception v0_1) {
                try {
                    arg6.b();
                } catch (Throwable v1_2) {
                }

                throw v0_1;
            }

            if (arg5[0] > 0) {
                v0 = v1_1;
            }
        }

        return v0;
    }

    public static void decodeBytes(byte[] bytes, int length) throws IOException {
        if (bytes != null && length > 0) {
            byte[] decodeKeys = new byte[]{-99, -114, 127, 90};
            for (int i = 0; i < length; ++i) {
                bytes[i] = (byte) (bytes[i] ^ decodeKeys[i % 4]);
            }
        }
    }

    public static String a(String arg3, String arg4) {
        String v0 = null;
        byte[] v1 = arg3.getBytes();
        try {
            if (isTextEmpty(arg4)) {
                arg4 = "SHA-256";
            }

            MessageDigest v2 = MessageDigest.getInstance(arg4);
            v2.update(v1);
            v0 = c(v2.digest());
        } catch (NoSuchAlgorithmException v1_2) {
        } catch (Exception e) {
        }
        return v0;
    }

    public static String a(String arg2, String arg3, String arg4) {
        if (isTextEmpty(arg2)) {
            JSONObject v0 = new JSONObject();
            try {
                if (!isTextEmpty(arg4)) {
                    v0.put("source", arg4);
                }

                if (!isTextEmpty(arg3)) {
                    v0.put("enter_from", arg4);
                }

                arg2 = v0.toString();
            } catch (Exception v0_1) {
                v0_1.printStackTrace();
            }

            return arg2;
        }

        if (!isTextEmpty(arg4)) {
            arg2 = JsonUtil.a(arg2, "source", arg4);
        }

        return arg2;
    }

    public static String a(String arg3, boolean arg4) {
        if (!isTextEmpty(arg3)) {
            StringBuilder v1 = new StringBuilder(arg3);
            AppUtil.a(v1);
            String v0 = v1.indexOf("#") > 0 ? "&" : "#";
            v1.append(v0);
            StringBuilder v2 = v1.append("tt_daymode=");
            char v0_1 = arg4 ? '0' : '1';
            v2.append(v0_1);
            arg3 = v1.toString();
        }

        return arg3;
    }

    public static String a(List arg5, String arg6) {
        StringBuilder v2 = new StringBuilder();
        Iterator v3 = arg5.iterator();
        while (v3.hasNext()) {
            Object v0 = v3.next();
            String v1 = h((String) ((Pair) v0).first, arg6);
            v0 = ((Pair) v0).second;
            String v0_1 = v0 != null ? h(((String) v0), arg6) : "";
            if (v2.length() > 0) {
                v2.append("&");
            }

            v2.append(v1);
            v2.append("=");
            v2.append(v0_1);
        }

        return v2.toString();
    }

    public static String a(Map arg6) {
        String v0;
        String v2 = null;
        if (arg6 == null) {
            v0 = v2;
            return v0;
        }

        try {
            JSONObject v3 = new JSONObject();
            Iterator v4 = arg6.keySet().iterator();
            while (v4.hasNext()) {
                Object v0_2 = v4.next();
                Object v1 = arg6.get(v0_2);
                if (isTextEmpty(((String) v0_2))) {
                    continue;
                }

                if (isTextEmpty(((String) v1))) {
                    continue;
                }

                v3.put(((String) v0_2), v1);
            }

            return v3.toString();

        } catch (Exception v0_1) {
            return v2;
        }
    }

    public static String a(HttpUrl arg3) {
        String v0 = arg3.encodedPath();
        String v1 = arg3.encodedQuery();
        if (v1 != null) {
            v0 = v0 + '?' + v1;
        }

        return v0;
    }

    public static String a(byte[] arg2, String arg3) throws Exception {
        String v0;
        if (arg2 == null) {
            v0 = null;
        } else {
            v0 = MimeUtil.parseCharset(arg3, "UTF-8");
            if (v0 == null) {
                v0 = "UTF-8";
            }

            v0 = new String(arg2, v0);
        }

        return v0;
    }

    public static StringBuilder a(StringBuilder arg2, String arg3, String arg4) {
        if (!TextUtils.isEmpty(((CharSequence) arg3)) && !TextUtils.isEmpty(((CharSequence) arg4))) {
            arg2.append("&").append(arg3).append("=").append(arg4);
        }

        return arg2;
    }

    public static URI a(String arg2, String arg3, int arg4, String arg5, String arg6, String arg7) throws URISyntaxException {
        StringBuilder v0 = new StringBuilder();
        if (arg3 != null) {
            if (arg2 != null) {
                v0.append(arg2);
                v0.append("://");
            }

            v0.append(arg3);
            if (arg4 <= 0) {
//                goto label_12;
            } else {
                v0.append(':');
                v0.append(arg4);
            }
        }

        label_12:
        if (arg5 == null || !arg5.startsWith("/")) {
            v0.append('/');
        }

        if (arg5 != null) {
            v0.append(arg5);
        }

        if (arg6 != null) {
            v0.append('?');
            v0.append(arg6);
        }

        if (arg7 != null) {
            v0.append('#');
            v0.append(arg7);
        }

        return new URI(v0.toString());
    }

    public static URI a(URI uri, com.bytedance.frameworks.baselib.network.http.util.c arg7) throws URISyntaxException {
        if (uri == null) {
            throw new IllegalArgumentException("URI may nor be null");
        }

        return a(arg7.scheme, arg7.hostName, arg7.b, uri.getRawPath(), uri.getRawQuery(), uri.getRawFragment());
    }

    public static Key a(byte[] arg2) throws Exception {
        return SecretKeyFactory.getInstance("DES").generateSecret(new DESKeySpec(arg2));
    }


    public static List a(List arg1, List arg2) {
        return a(arg1, arg2, true);
    }

    public static List a(List arg7, List arg8, boolean arg9) {
        Object v0_1;
        List v0;
        List v1;
        ArrayList v2 = new ArrayList();
        if (arg8 == null || (arg8.isEmpty())) {
            arg8 = v2;
        } else if (arg7 != null && !arg7.isEmpty()) {
            HashMap v3 = new HashMap();
            if (!arg9) {
                v1 = arg7;
                v0 = arg8;
            } else {
                v1 = arg8;
                v0 = arg7;
            }

            Iterator v4 = v0.iterator();
            while (v4.hasNext()) {
                v0_1 = v4.next();
                String v5 = ((CellRef) v0_1).cellId;
                if (isTextEmpty(v5)) {
                    continue;
                }

                v3.put(v5, v0_1);
            }

            Iterator v1_1 = v1.iterator();
            while (v1_1.hasNext()) {
                v0_1 = v1_1.next();
                String v4_1 = ((CellRef) v0_1).cellId;
                if (isTextEmpty(v4_1)) {
                    ((List) v2).add(v0_1);
                    continue;
                }

                if (v3.containsKey(v4_1)) {
                    continue;
                }

                v3.put(v4_1, v0_1);
                ((List) v2).add(v0_1);
            }

            if (arg9) {
                arg8 = v2;
                return arg8;
            }

            arg7.clear();
            arg7.addAll(((Collection) v2));
        }

        label_6:
        return ((List) arg8);
    }

    public static List a(JSONArray arg8) {
        ArrayList v0;
        ArrayList v1 = new ArrayList();
        if (arg8 == null) {
            v0 = v1;
        } else {
            int v0_1;
            for (v0_1 = 0; v0_1 < arg8.length(); ++v0_1) {
                JSONObject v2 = arg8.optJSONObject(v0_1);
                if (v2 != null) {
                    long id = v2.optLong("id");
                    if (id > 0) {
                        EntryItem entryItem = EntryItem.obtain(id);
                        entryItem.extractFields(v2);
                        com.ss.android.article.base.feature.subscribe.model.d v4_1 = new com.ss.android.article.base.feature.subscribe.model.d(entryItem);
                        v4_1.badge = v2.optInt("badge");
                        v4_1.itemDescription = v2.optString("item_description");
                        v4_1.lastTime = v2.optLong("last_time");
                        ((List) v1).add(v4_1);
                    }
                }
            }

            v0 = v1;
        }

        return ((List) v0);
    }

    public static Map a(String arg5, Map arg6) {
        if (!isTextEmpty(arg5) && arg6 != null) {
            try {
                JSONObject v1 = new JSONObject(arg5);
                Iterator v2 = v1.keys();
                while (true) {
                    if (v2.hasNext()) {
                        Object v0_1 = v2.next();
                        String v3 = v1.getString(((String) v0_1));
                        if (isTextEmpty(((String) v0_1))) {
                            continue;
                        }

                        if (isTextEmpty(v3)) {
                            continue;
                        }

                        arg6.put(v0_1, v3);
                        continue;
                    } else {
                        return arg6;
                    }
                }
            } catch (Exception v0) {
                return arg6;
            }
        }

        return null;
    }

    private synchronized static JSONArray removeJsonArrayItem(JSONArray jsonArray, int index) {
        JSONArray v0_1;
        int v2 = 1;
        if (index < 0) {
            return jsonArray;
        }

        if (index > jsonArray.length()) {
            return jsonArray;
        }

        Logger.d("AppDownloadInfoManager", "start, removeJsonArrayItem, index =  " + index + ", jsonArray = " + jsonArray);
        int v4 = jsonArray.length();
        v0_1 = new JSONArray();
        if (v4 != 1) {
//            goto label_25;
        } else {
            jsonArray = v0_1;
            return jsonArray;
        }
//        label_25:
        if (index != 0) {
            // goto label_38
            if (index != v4 - 1) {
//                goto label_51;
                v2 = 0;
                while (true) {
                    if (v2 >= index) {
//                        goto label_61;
                        break;
                    }

                    try {
                        v0_1.put(jsonArray.getJSONObject(v2));
                        ++v2;
                        continue;
                    } catch (JSONException v1) {
                        v1.printStackTrace();
                    }
                }

                v2 = index + 1;
                while (true) {
                    if (v2 >= v4) {
                        Logger.d("AppDownloadInfoManager", "end, removeJsonArrayItem, index =  " + index + ", newJsonArray = " + v0_1);
                        jsonArray = v0_1;
                        break;
                    }
                    try {
                        v0_1.put(jsonArray.getJSONObject(v2));
                        ++v2;
                        continue;
                    } catch (JSONException v1) {
                        v1.printStackTrace();
                    }
                }

            } else {
                v2 = 0;
                while (true) {
                    if (v2 >= v4 - 1) {
                        Logger.d("AppDownloadInfoManager", "end, removeJsonArrayItem, index =  " + index + ", newJsonArray = " + v0_1);
                        jsonArray = v0_1;
                        break;
                    }

                    try {
                        v0_1.put(jsonArray.getJSONObject(v2));
                        ++v2;
                        continue;
                    } catch (JSONException v1) {
                        v1.printStackTrace();
                    }
                }
                return jsonArray;
            }
        } else {
            while (true) {
                if (v2 >= v4) {
                    Logger.d("AppDownloadInfoManager", "end, removeJsonArrayItem, index =  " + index + ", newJsonArray = " + v0_1);
                    jsonArray = v0_1;
                    break;
                }

                try {
                    v0_1.put(jsonArray.getJSONObject(v2));
                    ++v2;
                    continue;
                } catch (JSONException v1) {
                    v1.printStackTrace();
                }
            }
        }
        return jsonArray;
    }

    public static JSONObject sendLoadStatusEvent(Context context, ArticleQueryObj articleQueryObj) {

        if (context != null && articleQueryObj != null && articleQueryObj.startTime > 0L) {
            if (articleQueryObj.netRequestTime <= 0L) {
                if (articleQueryObj.localLoadTime <= 0L) {
                    return null;
                }
            }

            try {
                JSONObject jsonObject = null;
                long totalTime = System.currentTimeMillis() - articleQueryObj.startTime;
                jsonObject = new JSONObject();
                if (articleQueryObj.netRequestTime > 0L) {
                    jsonObject.put("net_request_time", articleQueryObj.netRequestTime);
                }

                if (articleQueryObj.localLoadTime > 0L) {
                    jsonObject.put("local_load_time", articleQueryObj.localLoadTime);
                }

                jsonObject.put("total_time", totalTime);
                if (!isTextEmpty(articleQueryObj.exception)) {
                    jsonObject.put("exception", articleQueryObj.exception);
                }

                if (!isTextEmpty(articleQueryObj.exceptionMsg)) {
                    jsonObject.put("exception_msg", articleQueryObj.exceptionMsg);
                }

                if (!isTextEmpty(articleQueryObj.errorIp)) {
                    jsonObject.put("error_ip", articleQueryObj.errorIp);
                }

                if (!Logger.debug()) {
                    return jsonObject;
                }
                Logger.d("Performance", "PerformanceTraceUtils.sendLoadStatusEvent:" + jsonObject.toString());
                return jsonObject;
            } catch (JSONException jsonException) {
                jsonException.printStackTrace();
            }
        }
        return null;
    }

    public static void endSection() {
        if (Build.VERSION.SDK_INT >= 18) {
            Trace.endSection();
        }
    }

    public static void a(int arg3, String arg4) {
        FileWriter v1 = null;
        File v0 = new File(arg4);
        if (v0.exists()) {
            return;
        }

        FileWriter v2 = null;
        try {
            v1 = new FileWriter(v0);
            v1.write("LOWM\r\nrecv low memory warring info.level:" + arg3);
        } catch (IOException v0_2) {
            v0_2.printStackTrace();
        } finally {
            if (v1 != null) {
                try {
                    v1.close();
                } catch (Exception e) {
                }
            }
        }
    }

    public static void a(long arg14, long arg16, String arg18, String arg19, String arg20, int arg21, JSONObject arg22) {
        try {
            if (com.bytedance.framwork.core.monitor.c.j() == null) {
                com.bytedance.framwork.core.monitor.a.a().a(new com.bytedance.framwork.core.monitor.a.a$a("api_all", arg14, arg16, arg18, arg19, arg20, arg21, arg22));
                return;
            }

            if (f()) {
                com.bytedance.framwork.core.monitor.c v2_1 = com.bytedance.framwork.core.monitor.c.j();
                if (v2_1.a(arg18)) {
                    return;
                }

                if (v2_1.e(arg18)) {
                    return;
                }

                if (!NetworkDemo.c(v2_1.a)) {
                    return;
                }

                JSONObject v4 = v2_1.a("api_all", arg14, arg16, arg18, arg19, arg20, arg21);
                com.bytedance.framwork.core.monitor.c.a(v4, arg22);
                int v3;
                if ((TextUtils.isEmpty(arg18)) || v2_1.f == null || (v2_1.f.isEmpty())) {
                    v3 = 0;
                } else {
                    Iterator<String> v5 = v2_1.f.iterator();
                    do {
                        if (v5.hasNext()) {
                            if (!arg18.contains(v5.next())) {
                                continue;
                            }
                            v3 = 1;
                            break;
                        } else {
                            v3 = 0;
                            break;
                        }
                    }
                    while (true);
                }
                if (v3 != 0 || v2_1.d != 0) {
                    if (v4 == null) {
                        return;
                    }

                    if (v2_1.b == null) {
                        return;
                    }

                    v2_1.b.a("api_all", v4.toString());
                    return;
                }

                if (v2_1.i == 1) {
                    b("api_all", v4);
                }
            }

            return;
        } catch (Throwable v2) {
            return;
        }
    }

    public static void a(Activity arg1, int arg2, com.ss.android.article.browser.dialog.d[] arg3) {
        a(arg1, arg1.getString(arg2), arg3);
    }

    public static void a(Activity activity, String arg12, com.ss.android.article.browser.dialog.d[] arg13) {
        ViewGroup v10 = null;
        AlertDialog.Builder v3 = new AlertDialog.Builder((activity));
        View v4 = LayoutInflater.from((activity)).inflate(com.ss.android.article.browser.R.layout.ez, v10);
        View v0 = v4.findViewById(com.ss.android.article.browser.R.id.r6);
        View v1 = v4.findViewById(com.ss.android.article.browser.R.id.y0);
        ArrayAdapter v5 = new ArrayAdapter(activity, android.R.layout.simple_list_item_1);
        ArrayList<com.ss.android.article.browser.dialog.d> v6 = new ArrayList(1);
        int v7 = arg13.length;
        int v2;
        for (v2 = 0; v2 < v7; ++v2) {
            com.ss.android.article.browser.dialog.d v8 = arg13[v2];
            if (v8.b) {
                v6.add(v8);
            }
        }

        Iterator<com.ss.android.article.browser.dialog.d> v7_1 = ((List) v6).iterator();
        while (v7_1.hasNext()) {
            v5.add(activity.getString(v7_1.next().a));
        }

        if (!TextUtils.isEmpty(((CharSequence) arg12))) {
            ((TextView) v0).setText(((CharSequence) arg12));
        }

        ((ListView) v1).setAdapter(((ListAdapter) v5));
        ((ListView) v1).setDivider(((Drawable) null));
        v3.setCustomTitle(v4);
        AlertDialog v0_1 = v3.show();
        resizeDialog(((Context) activity), ((Dialog) v0_1));
        ((ListView) v1).setOnItemClickListener(new com.ss.android.article.browser.dialog.a(((List) v6), ((Dialog) v0_1)));
    }

    public static void a(Activity arg1, View arg2) {
        if ((arg2 instanceof SwipeOverlayFrameLayout)) {
            ((SwipeOverlayFrameLayout) arg2).setOnSwipeListener(new com.ss.android.topic.f.b(arg1));
        }
    }

    public static void showToast(Context arg1, String arg2, Drawable arg3) {
        a(arg1, arg2, arg3, 1500);
    }

    public static void a(Context arg4, int arg5, String arg6) {
        try {
            LinkedHashMap v0_1 = new LinkedHashMap();
            switch (arg5) {
                case 1: {
                    ((Map) v0_1).put("ssids", arg6);
                    break;
                }
                case 2: {
                    ((Map) v0_1).put("dns", arg6);
                    break;
                }
                case 3: {
                    ((Map) v0_1).put("https_dns", arg6);
                    break;
                }
            }

            if (Logger.debug()) {
                Logger.d("PushService", "saveData = " + arg6);
            }

            com.bytedance.ttnet.cc.a().a(arg4, ((Map) v0_1));
            return;
        } catch (Exception v0) {
            return;
        }
    }

    public static void onQQResponeLog(Context arg10, int arg11, boolean arg12) {
        long v4;
        String v2_1;
        JSONObject v8 = null;
        ShareBaseResp v1_1;
        long v6 = 0;
        ShareRespEntry v9 = null;
        int v3 = 45;
        ShareRespEntry v1 = AbsShareHelper.entry;
        if (v1 != null) {
            ShareBaseResp v2 = new ShareBaseResp(v1);
            v2.errCode = arg11;
            String v0 = arg12 ? "qzone_share_error_code" : "qq_share_error_code";
            v2.errCodeLabel = v0;
            if (!arg12) {
                if (v1.gtype == v3) {
                    v0 = arg11 == 0 ? "hotsoon_list_share_qq_done" : "hotsoon_list_share_qq_fail";
                    v2.label = v0;
                } else {
                    if (arg11 == 0) {
                        v0 = "share_qq_done";
                        v1_1 = v2;
                    } else {
                        v0 = "share_qq_fail";
                        v1_1 = v2;
                    }
                    v1_1.label = v0;
                }
            } else if (v1.gtype == v3) {
                v0 = arg11 == 0 ? "hotsoon_list_share_qzone_done" : "hotsoon_list_share_qzone_fail";
                v2.label = v0;
            } else {
                v0 = "share_qzone_done";
                v1_1 = v2;
                v1_1.label = v0;
            }
            if (v2.entry != null) {
                v1 = v2.entry;
                try {
                    if (v1.extJsonObj == null) {
                        v1.extJsonObj = new JSONObject();
                    }

                    v1.extJsonObj.put("group_id", v1.groupId);
                    v1.extJsonObj.put("title", v1.title);
                    v1.extJsonObj.put("gtype", v1.gtype);
                    v1.extJsonObj.put("item_id", v1.itemId);
                    v8 = new JSONObject(v1.extJsonObj.toString());
                    v8.put(v2.errCodeLabel, v2.errCode);
                } catch (JSONException v0_1) {
                    v0_1.printStackTrace();
                }

                String v3_1 = v2.label;
                if (isTextEmpty(v3_1)) {

                } else if (arg10 != null) {
                    if (!isTextEmpty(v1.eventName)) {
                        v2_1 = v1.eventName;
                    } else {
                        v0 = "";
                        switch (v1.shareSource) {
                            case 199: {
                                v0 = "detail_mid_share";
                                break;
                            }
                            case 201: {
                                v0 = "list_share";
                                break;
                            }
                            case 202: {
                                v0 = "share_topic";
                                break;
                            }
                            case 203: {
                                v0 = "share_update_post";
                                break;
                            }
                            case 204: {
                                v0 = "share_topic_post";
                                break;
                            }
                            case 205: {
                                v0 = "pgc_profile";
                                break;
                            }
                            case 207: {
                                v0 = "share_topic_post";
                                break;
                            }
                            case 200:
                            case 208: {
                                v0 = "detail_share";
                                break;
                            }
                            case 209: {
                                v0 = "share_concern";
                                break;
                            }
                            case 211: {
                                v0 = "share_answer_list";
                                break;
                            }
                            case 212: {
                                v0 = "share_live_chat";
                                break;
                            }
                            case 213: {
                                v0 = "list_share";
                                break;
                            }
                        }

                        v2_1 = v0;
                    }

                    switch (v1.shareSource) {
                        case 203:
                        case 204: {
                            v4 = v1.updateId;
                            break;
                        }
                        case 205: {
                            v4 = v1.pgcId;
                            break;
                        }
                        case 209: {
                            v4 = v1.m;
                            break;
                        }
                        case 211: {
                            v4 = v1.n;
                            break;
                        }
                        case 212: {
                            v4 = v1.l;
                            break;
                        }
                        case 199:
                        case 200:
                        case 201:
                        case 213: {
                            v4 = v1.groupId;
                            break;
                        }
                        default: {
                            v4 = v6;
                            break;
                        }
                    }

                    switch (v1.shareSource) {
                        case 199:
                        case 200:
                        case 201: {
                            v6 = v1.adId;
                            break;
                        }
                    }
                    MobClickCombiner.onEvent(arg10, v2_1, v3_1, v4, v6, v8);
                }
            }

            label_53:
            AbsShareHelper.entry = v9;
        }
    }

    public static void a(Context context, GradientDrawable backgroundDrawable) {
        if (backgroundDrawable == null || context == null) {
            Logger.throwException("backgroundDrawable or context is null!!!");
        }

        int v0 = ((int) UIUtils.dp2px(context, 0.5f));
        backgroundDrawable.setColor(0);
        backgroundDrawable.setStroke(v0, 0);
    }

    public static void a(Context context, TextView arg3, int arg4, String arg5) {
        if (isTextEmpty(arg5)) {
            UIUtils.setVisibility(((View) arg3), 8);
        } else {
            arg3.setText(((CharSequence) arg5));
            Drawable backgroundDrawable = arg3.getBackground();
            if (backgroundDrawable == null || !(backgroundDrawable instanceof GradientDrawable)) {
                backgroundDrawable = context.getResources().getDrawable(com.ss.android.article.browser.R.drawable.gd);
            }

            a(context, ((GradientDrawable) backgroundDrawable));
            int v1 = b(context, arg4);
            UIUtils.setBackgroundDrawable(((View) arg3), backgroundDrawable);
            arg3.setTextColor(v1);
            UIUtils.setVisibility(((View) arg3), 0);
            if (backgroundDrawable == null || context == null) {
                Logger.throwException("backgroundDrawable or context is null, or label less than 0!!!");
            }

            ((GradientDrawable) backgroundDrawable).setCornerRadius(((float) (((int) UIUtils.dp2px(context, 3f)))));
        }
    }

    public static void a(Context context, ImageLoader imageLoader, List arg10, int arg11, PriorityLinearLayout arg12, CardViewPools cardViewPools, int arg14) {
        ImageView v1_2;
        ColorFilter v3 = null;
        if (context != null && imageLoader != null && arg10 != null && arg10.size() != 0 && arg12 != null && arg11 > 0) {
            int v0 = arg12.getChildCount();
            Iterator v4 = arg10.iterator();
            int v2;
            for (v2 = v0; v4.hasNext(); ++v2) {
                Object v0_1 = v4.next();
                if (v0_1 == null) {
                    continue;
                }

                if (((ImageInfo) v0_1).mWidth <= 0) {
                    continue;
                }

                if (((ImageInfo) v0_1).mHeight <= 0) {
                    continue;
                }

                ((ImageInfo) v0_1).mNeedAlpha = true;
                int v1 = Math.min(arg11, ((ImageInfo) v0_1).mHeight);
                com.ss.android.article.base.ui.PriorityLinearLayout.PriorityLinearLayout$a v6 =
                        new com.ss.android.article.base.ui.PriorityLinearLayout.PriorityLinearLayout$a(
                                ((ImageInfo) v0_1).mWidth * v1 / ((ImageInfo) v0_1).mHeight, v1);
                v6.a = v2;
                v6.b = v2;
                v6.leftMargin = arg14;
                View v1_1 = cardViewPools != null ? cardViewPools.acquire(1) : ((View) null);
                if (v1_1 == null) {
                    v1_1 = new ImageView(context);
                }

                ((ImageView) v1_1).setScaleType(ImageView.ScaleType.FIT_CENTER);
                com.ss.android.j.b.isNightModeToggled();
                ((ImageView) v1_1).setImageResource(com.ss.android.article.browser.R.drawable.simple_image_holder_listpage);
                com.ss.android.j.b.isNightModeToggled();
                ((ImageView) v1_1).setColorFilter(v3);
                if (!isTextEmpty(((ImageInfo) v0_1).mOpenUrl)) {
                    ((ImageView) v1_1).setOnClickListener(new com.ss.android.article.base.utils.j(context, ((ImageInfo) v0_1)));
                } else {
                    ((ImageView) v1_1).setOnClickListener(((View.OnClickListener) v3));
                }

                arg12.addView((v1_1), ((ViewGroup.LayoutParams) v6));
                imageLoader.loadImage(((ImageView) v1_1), ((ImageInfo) v0_1), false);
            }

            arg12.a();
        }
    }

    public static void a(Context arg2, String arg3, String arg4) {
        a(arg2, "register_new", arg3, arg4, -1);
    }

    public static void a(Context arg9, String arg10, String arg11, String arg12, int arg13) {
        long v4 = 0;
        Logger.i("event:" + arg10 + " label:" + arg11 + " source:" + arg12);
        if (isTextEmpty(arg12)) {
            arg12 = "other";
        }

        JSONObject v8 = new JSONObject();
        try {
            v8.put("source", arg12);
            if (arg13 < 0) {
            } else {
                v8.put("sim", arg13);
            }
        } catch (JSONException v0) {
        }

        MobClickCombiner.onEvent(arg9, null, arg10, arg11, v4, v4, v8);
    }

    public static void a(Context arg9, StringBuilder arg10) {
        int v8 = 2;
        String[] v0 = E();
        if (v0 != null) {
            Object[] v2 = new Object[3];
            v2[0] = v0[0];
            v2[1] = v0[1];
            v2[v8] = v0[v8];
            arg10.append(String.format("version:%s,%s,%s\r\n", v2)).append("\r\n");
        }

        long[] v0_1 = com.ss.ttm.a.c.a();
        if (v0_1 != null) {
            arg10.append(String.format("rom memory totle:%d,availe:%d\r\n", Long.valueOf(v0_1[0]), Long.valueOf(v0_1[1]))).append("\r\n");
        }

        long v0_2 = com.ss.ttm.a.c.a(arg9);
        long v2_1 = com.ss.ttm.a.c.b();
        arg10.append(String.format("ram memory totle:%d,availe:%d\r\n", Long.valueOf(v2_1), Long.valueOf(v0_2))).append("\r\n");
        v0_1 = com.ss.ttm.a.b.a();
        arg10.append(String.format("sdcard totle:%d,availe:%d\r\n", Long.valueOf(v0_1[0]), Long.valueOf(v0_1[1]))).append("\r\n");
    }

    public static void a(Context arg2, StringBuilder arg3, String arg4, String arg5) {
        if (Y == null) {
            Y = new StringBuilder();
            a(arg2, Y);
        }

        arg3.append(Y);
        arg3.append("\r\n").append(arg4).append(":").append(arg5);
    }

    public static void setAlpha(View view, int alpha) {
        if (view != null) {
            Drawable background = view.getBackground();
            if (background != null) {
                background.setAlpha(alpha);
            }
        }
    }

    public static void a(View arg7, TipsType[] arg8) {
        if (arg7 != null) {
            int v5;
            for (v5 = 0; v5 <= 0; ++v5) {
                int v1 = arg8[0].ordinal();
                ViewParent v0 = arg7.getParent();
                if ((v0 instanceof com.ss.android.topic.tips.b)) {
                    View v1_1 = a(((ViewGroup) v0), v1);
                    v0 = arg7.getParent();
                    if ((v0 instanceof com.ss.android.topic.tips.b)) {
                        ((ViewGroup) v0).removeView(v1_1);
                        int v2 = 0;
                        while (true) {
                            if (v2 >= ((ViewGroup) v0).getChildCount()) {
                                v1 = 0;
                                break;
                            } else if (((ViewGroup) v0).getChildAt(v2).getTag() != null) {
                                v1 = 1;
                            } else {
                                ++v2;
                                continue;
                            }
                            break;
                        }
                        v1 = v1 != 0 ? 4 : 0;
                        arg7.setVisibility(v1);
                        if (((ViewGroup) v0).getChildCount() != 1) {
                            continue;
                        }

                        ViewParent v1_2 = ((ViewGroup) v0).getParent();
                        ViewGroup.LayoutParams v2_1 = ((ViewGroup) v0).getLayoutParams();
                        int v6 = ((ViewGroup) v1_2).indexOfChild(((View) v0));
                        ((ViewGroup) v1_2).removeViewAt(v6);
                        if (arg7.getParent() != null) {
                            ((ViewGroup) arg7.getParent()).removeView(arg7);
                        }

                        ((ViewGroup) v1_2).addView(arg7, v6, v2_1);
                    }
                }
            }
        }
    }

    public static void removeImageInfoTag(ImageView imageView) {
        if (imageView != null) {
            imageView.setTag(com.ss.android.article.browser.R.id.image_info, null);
        }
    }

    public static void a(TextView arg1, int arg2) {
        arg1.setText(c(arg2));
    }

    public static void a(JsonElement arg1, JsonWriter arg2) throws IOException {
        TypeAdapters.JSON_ELEMENT.write(arg2, arg1);
    }

    public static synchronized void a(com.ss.android.article.base.feature.b.a arg10, boolean arg11) {
        int v2_1;
        JSONArray v3_2;
        int v3_1;
        JSONArray v2;
        String v3;
        int v1 = 0;
        int v0 = 1;
        if (arg10 == null) {
            return;
        }
        try {
            SharedPreferenceUtils.inst();
            v3 = SharedPreferenceUtils.getString(null, "app_ad_download", "");
            Logger.d("AppDownloadInfoManager", "saveOrRemoveDownInfoToFile, info.adId =  " + arg10.a + ", downloadInfoJSonStr = " + v3 + ", isRemove = " + arg11);
            if (isTextEmpty(v3)) {
                v2 = new JSONArray();
            } else {
                v2 = new JSONArray(v3);
            }
            int v5 = v2.length();
            v3_1 = 0;
            while (true) {
                if (v3_1 < v5) {
                    com.ss.android.article.base.feature.b.a v6 = com.ss.android.article.base.feature.b.a.a(v2.getJSONObject(v3_1));
                    if (v6 != null && v6.a == arg10.a) {
                        if (arg11) {
                            v3_2 = removeJsonArrayItem(v2, v3_1);
                            v2_1 = 0;
                            v1 = 1;
                            break;
                        } else {
                            v2.put(v3_1, arg10.a());
                            v1 = 1;
                            v3_2 = v2;
                            v2_1 = 1;
                            break;
                        }
                    }
                    ++v3_1;
                    continue;
                } else {
                    v3_2 = v2;
                    v2_1 = 0;
                    break;
                }
            }
            if (v3_2 == null) {
                return;
            }

            if (v2_1 != 0) {
                v0 = v1;
            } else if (!arg11) {
                v3_2.put(arg10.a());
            } else {
                v0 = v1;
            }
            if (v0 == 0) {
                return;
            }
            SharedPreferenceUtils.inst();
            SharedPreferences.Editor v0_3 = SharedPreferenceUtils.getEditor("main_app_settings");
            v0_3.putString("app_ad_download", v3_2.toString());
            SharedPreferenceCompat.commit(v0_3);
            Logger.d("AppDownloadInfoManager", "saveOrRemoveDownInfoToFile success, info.adId =  " + arg10.a + ", jsonArray.toString() = " + v3_2.toString() + ", isRemove = " + arg11);
        } catch (Exception v0_2) {
            Logger.d("AppDownloadInfoManager", "saveOrRemoveDownInfoToFile, info.adId =  " + arg10.a + ", Exception, e.getCause() =  " + v0_2.getCause());
            v0_2.printStackTrace();
        }
    }

    public static void a(PriorityLinearLayout arg6, ImageLoader arg7, CardViewPools arg8) {
        Bitmap v5 = null;
        int v1 = 3;
        if (arg6 != null && arg6.getChildCount() > v1) {
            int v2 = arg6.getChildCount();
            ArrayList v3 = new ArrayList();
            int v0;
            for (v0 = v1; v0 < v2; ++v0) {
                v3.add(arg6.getChildAt(v0));
            }

            arg6.removeViews(v1, v2 - 3);
            Iterator v2_1 = v3.iterator();
            while (v2_1.hasNext()) {
                Object v0_1 = v2_1.next();
                if (!(v0_1 instanceof ImageView)) {
                    continue;
                }

                Object v1_1 = v0_1;
                if (arg7 != null) {
                    arg7.clear(((ImageView) v1_1));
                }

                ((ImageView) v1_1).setImageBitmap(v5);
                ((ImageView) v1_1).setOnClickListener(((View.OnClickListener) null));
                if (arg8 == null) {
                    continue;
                }

                arg8.release(1, ((View) v0_1));
            }

            arg6.a();
        }
    }

    public static void setImage(AsyncImageView imageView, ImageInfo imageInfo) {
        if (imageView != null && imageInfo != null) {
            Image image = imageInfo2Image(imageInfo);
            if (image != null) {
                imageView.setImage(image, null);
            }
        }
    }

    public static void preloadImage(ImageInfo imageInfo, Context context) {
        if (imageInfo != null) {
            Image image = imageInfo2Image(imageInfo);
            if (image.url_list != null) {
                for (int i = 0; i < image.url_list.size(); i++) {
                    String url = image.url_list.get(i).url;
                    if (!FrescoUtils.isCached(Uri.parse(url))) {
                        FrescoUtils.preload(Uri.parse(url), context);
                    }
                }
            }
        }
    }

    public static void closeQuietly(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
            }
        }
    }

    public static void closeQuietly(Closeable closeable, String messageOnException) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (Exception e) {
                if (!Logger.debug()) {
                    return;
                }
                if (messageOnException != null) {
                    Logger.d("NetworkUtils", messageOnException + " " + e);
                }
            }
        }
    }

    private static void a(InputStream arg3, OutputStream arg4) throws IOException {
        BufferedOutputStream v4 = null;
        BufferedInputStream v3 = null;
        int v0 = 524288;
        try {
            byte[] v1 = new byte[v0];
            if (!(arg3 instanceof BufferedInputStream)) {
                v3 = new BufferedInputStream(arg3, 524288);
            }

            if (!(arg4 instanceof BufferedOutputStream)) {
                v4 = new BufferedOutputStream(arg4, 524288);
            }

            while (true) {
                v0 = ((InputStream) v3).read(v1);
                if (v0 == -1) {
                    break;
                }

                ((OutputStream) v4).write(v1, 0, v0);
                ((OutputStream) v4).flush();
            }
            ((OutputStream) v4).flush();
        } catch (IOException v0_1) {
        } finally {
            c(((Closeable) v3));
        }
    }

    private static void a(Class arg5, Set arg6) {
        while (arg5 != null) {
            if (arg5 == Object.class) {
                return;
            }

            Class[] v1 = arg5.getInterfaces();
            if (v1 != null && v1.length > 0) {
                int v2 = v1.length;
                int v0;
                for (v0 = 0; v0 < v2; ++v0) {
                    Class v3 = v1[v0];
                    if (arg6.add(v3)) {
                        a(v3, arg6);
                    }
                }
            }

            arg5 = arg5.getSuperclass();
        }
    }

    public static boolean containedBeforeIndex(List arg3, View arg4, int arg5) {
        boolean v0 = false;
        int v1 = 0;
        while (v1 < arg5) {
            if (arg3.get(v1) == arg4) {
                v0 = true;
            } else {
                ++v1;
                continue;
            }

            return v0;
        }

        return v0;
    }


    @SuppressLint("NewApi")
    public static void removeTargets(Object arg3, ArrayList<View> arg4) {
        int v1;
        if ((arg3 instanceof TransitionSet)) {
            v1 = ((TransitionSet) arg3).getTransitionCount();
            int v0;
            for (v0 = 0; v0 < v1; ++v0) {
                removeTargets(((TransitionSet) arg3).getTransitionAt(v0), arg4);
            }
        } else if (!hasSimpleTarget(((Transition) arg3))) {
            List v0_1 = ((Transition) arg3).getTargets();
            if (v0_1 != null && v0_1.size() == arg4.size() && (v0_1.containsAll(((Collection) arg4)))) {
                for (v1 = arg4.size() - 1; v1 >= 0; --v1) {
                    ((Transition) arg3).removeTarget(arg4.get(v1));
                }
            }
        }
    }

    @SuppressLint("NewApi")
    public static boolean hasSimpleTarget(Transition arg1) {
        boolean v0 = !isNullOrEmpty(arg1.getTargetIds()) || !isNullOrEmpty(arg1.getTargetNames()) || !isNullOrEmpty(arg1.getTargetTypes()) ? true : false;
        return v0;
    }

    public static void a(String arg5, int arg6, Callback arg7, String arg8) {
        HashMap v1 = new HashMap();
        ((Map) v1).put("qid", arg5);
        ((Map) v1).put("follow_type", String.valueOf(arg6));
        if (!isTextEmpty(arg8)) {
            ((Map) v1).put("api_param", arg8);
        }

        Object v0 = com.ss.android.topic.aa.a("http://ib.snssdk.com", IWendaApi.class);
        if (v0 != null) {
            FormUrlEncodedTypedOutput v3 = new FormUrlEncodedTypedOutput();
            Iterator v4 = ((Map) v1).entrySet().iterator();
            while (v4.hasNext()) {
                Map.Entry<String, String> v2 = (Map.Entry<String, String>) v4.next();
                v3.addField(v2.getKey(), v2.getValue());
            }

            ((IWendaApi) v0).followQuestion(((TypedOutput) v3)).enqueue(arg7);
        }
    }

    public static void a(String arg2, int arg3, JSONObject arg4, JSONObject arg5) {
        try {
            if (com.bytedance.framwork.core.monitor.c.j() == null) {
                com.bytedance.framwork.core.monitor.a.a().a(new com.bytedance.framwork.core.monitor.a.d(arg2, arg3, arg4, arg5));
                return;
            }

            if (!n(arg2)) {
                return;
            }

            b(arg2, arg3, arg4, arg5);
        } catch (Throwable v0) {
        }
    }

    public static void a(String arg3, long arg4) {
        com.bytedance.article.common.a.g.a(arg3, "duration", ((float) arg4));
        int v0 = (arg3.startsWith("appConstructor")) || (arg3.startsWith("appOnCreate"))
                || (arg3.startsWith("splashOn")) || (arg3.startsWith("mainOn"))
                || (arg3.equals("firstApplicationToFeedShown")) || (arg3.equals("hotApplicationToFeedShown"))
                || (arg3.equals("applicationToFeedShown")) || (arg3.equals("applicationDelayToFeedShown")) ? 1 : 0;
        if (v0 != 0) {
            Logger.i("startup", "onTimer " + arg3 + " cost " + arg4);
        }
    }

    public static void a(String arg7, String arg8, float arg9) {
        try {
            if (com.bytedance.framwork.core.monitor.c.j() == null) {
                com.bytedance.framwork.core.monitor.a.a().a(new com.bytedance.framwork.core.monitor.a.c(arg7, arg8, arg9, true, "counter"));
                return;
            }

            if (!o(arg7)) {
                return;
            }

            if (e() == null) {
                return;
            }

            if (!f()) {
                return;
            }

            e().b(arg7, arg8, arg9);
        } catch (Throwable v0) {
        }
    }

    public static void a(String arg4, String arg5, String arg6, Callback arg7) {
        HashMap v1 = new HashMap();
        ((Map) v1).put("ansid", arg4);
        ((Map) v1).put("enter_from", arg5);
        if (!isTextEmpty(arg6)) {
            ((Map) v1).put("api_param", arg6);
        }

        Object v0 = com.ss.android.topic.aa.a("http://ib.snssdk.com", IWendaApi.class);
        if (v0 != null) {
            ((IWendaApi) v0).postFormUrl(20480, "/wenda/v1/commit/digganswer/", ((Map) v1)).enqueue(arg7);
        }
    }

    public static void a(String arg5, JSONObject arg6) {
        long v2_1;
        LinkedList v2;
        com.bytedance.framwork.core.monitor.a.b v1;
        com.bytedance.framwork.core.monitor.a v0_1;
        try {
            if (com.bytedance.framwork.core.monitor.c.j() != null) {

            } else {
                v0_1 = com.bytedance.framwork.core.monitor.a.a();
                v1 = new com.bytedance.framwork.core.monitor.a.b(arg5, arg6);
                v2 = v0_1.a;
                synchronized (v2) {
                    if (v0_1.a.size() > v0_1.b) {
                        v0_1.a.poll();
                    }

                    v0_1.a.add(v1);
                }
                return;
            }
            if (!m(arg5)) {
                return;
            }

            if (arg6 == null) {
                return;
            }

            com.bytedance.framwork.core.monitor.c.j();
            if (!com.bytedance.framwork.core.monitor.c.k()) {
                return;
            }
        } catch (Throwable v0) {
            return;
        }

        try {
            arg6.put("log_type", arg5);
            arg6.put("network_type", C());
            v2_1 = System.currentTimeMillis();
            arg6.put("timestamp", v2_1);
            e().a(arg5, arg6.toString());
        } catch (Throwable throwable) {
        }
    }

    public static void a(String arg4, String[] arg5) {
        int v0 = 0;
        JSONObject v1 = new JSONObject();
        while (v0 < 2) {
            try {
                v1.put(arg5[0], arg5[1]);
                v0 += 2;
                continue;
            } catch (Exception v0_1) {
                v0_1.printStackTrace();
                break;
            }
        }

        onEvent(arg4, v1);
    }

    public static void a(StringBuilder arg7, Context arg8) {
        int v3 = 10;
        com.ss.android.lockscreen.e.a v1 = com.ss.android.lockscreen.bb.a().b;
        String v0 = v1 == null ? "" : AbsApplication.getApplication().getAid() + "";
        if (!TextDemo.c(v0)) {
            arg7.append("&aid=").append(v0);
        }

        v0 = v1 == null ? "" : AppLog.deviceId();
        if (!TextDemo.c(v0)) {
            arg7.append("&did=").append(v0);
        }

        v0 = v1 == null ? "" : AppData.getInstance().currentCityName;
        if (!TextDemo.c(v0)) {
            arg7.append("&city=").append(v0);
        }

        v0 = v1 == null ? "" : AppLog.i();
        if (!TextDemo.c(v0)) {
            arg7.append("&uid=").append(v0);
        }

        v0 = F(arg8);
        if (!TextDemo.c(v0)) {
            arg7.append("&openudid=").append(v0);
        }

        v0 = v1 == null ? "" : AbsApplication.getApplication().getChannel();
        if (!TextDemo.c(v0)) {
            arg7.append("&channel=").append(v0);
        }

        arg7.append("&os=Android");
        v0 = Build.VERSION.RELEASE;
        if (v0 != null && v0.length() > v3) {
            v0 = v0.substring(0, v3);
        }

        arg7.append("&os_version=").append(v0);
        v0 = String.valueOf(Build.VERSION.SDK_INT);
        if (!TextDemo.c(v0)) {
            arg7.append("&os_api=").append(v0);
        }

        v0 = Build.BRAND;
        if (!TextDemo.c(v0)) {
            arg7.append("&device_brand=").append(v0);
        }

        String v1_1 = Build.MANUFACTURER;
        if (!TextDemo.c(v0)) {
            arg7.append("&device_manufacturer=").append(v1_1);
        }

        v0 = Build.MODEL;
        if (!TextDemo.c(v0)) {
            arg7.append("&device_model=").append(v0);
        }

        v0 = com.ss.android.lockscreen.utils.c.a(arg8);
        if (!TextDemo.c(v0)) {
            arg7.append("&resolution=").append(v0);
        }

        int v0_1 = com.ss.android.lockscreen.utils.c.b(arg8);
        if (v0_1 > 0) {
            arg7.append("&display_density=").append(String.valueOf(v0_1));
        }

        v0 = String.valueOf(System.currentTimeMillis());
        arg7.append("&timestamp=").append(v0);
        v1_1 = String.valueOf(((long) (Math.random() * 1000000)));
        arg7.append("&nonce=").append(v1_1);
        arg7.append("&partner=litelocks");
        ArrayList<String> v2 = new ArrayList();
        ((List) v2).add("2fc4dca49a5c2155af0c36c8fdb18b4b");
        ((List) v2).add(v0);
        ((List) v2).add(v1_1);
        ((List) v2).add("litelocks");
        Collections.sort(((List) v2));
        arg7.append("&signature=").append(M(v2.get(0) + v2.get(1) + v2.get(2)));
        arg7.append("&latitude=").append(com.ss.android.lockscreen.b.a.a(arg8));
        arg7.append("&longitude=").append(com.ss.android.lockscreen.b.a.b(arg8));
    }

    public static void a(Throwable arg9) {
        int v2;
        int v8 = 1024;
        int v0 = 0;
        com.bytedance.article.common.a.d.c.a();
        if (com.bytedance.article.common.a.d.c.b()) {
            if ((arg9 instanceof ConnectTimeoutException)) {
                v2 = 1;
            } else if ((arg9 instanceof SocketTimeoutException)) {
                v2 = 1;
            } else if ((arg9 instanceof BindException)) {
                v2 = 1;
            } else if ((arg9 instanceof ConnectException)) {
                v2 = 1;
            } else if ((arg9 instanceof NoRouteToHostException)) {
                v2 = 1;
            } else if ((arg9 instanceof PortUnreachableException)) {
                v2 = 1;
            } else if ((arg9 instanceof SocketException)) {
                v2 = 1;
            } else if ((arg9 instanceof UnknownHostException)) {
                v2 = 1;
            } else if ((arg9 instanceof NoRouteToHostException)) {
                v2 = 1;
            } else if ((arg9 instanceof ProtocolException)) {
                v2 = 1;
            } else if ((arg9 instanceof SSLException)) {
                v2 = 1;
            } else if ((arg9 instanceof ConnectTimeoutException)) {
                v2 = 1;
            } else if ((arg9 instanceof SSLHandshakeException)) {
                v2 = 1;
            } else {
                v2 = 0;
            }

            if (v2 == 0) {
                v0 = 1;
            }
        } else {
            v0 = 1;
        }

        if (v0 != 0) {
            StackTraceElement[] v0_1 = Thread.currentThread().getStackTrace();
            int v1 = 3;
            try {
                StackTraceElement v0_3 = v0_1[v1];
                String v1_1 = v0_3.getClassName();
                String v2_1 = v0_3.getMethodName();
                int v3 = v0_3.getLineNumber();
                StringWriter v0_4 = new StringWriter();
                PrintWriter v4 = new PrintWriter(((Writer) v0_4));
                arg9.printStackTrace(v4);
                Throwable v5 = arg9.getCause();
                if (v5 != null) {
                    v5.printStackTrace(v4);
                    v5 = v5.getCause();
                    if (v5 != null) {
                        v5.printStackTrace(v4);
                    }
                }

                String v0_5 = v0_4.toString();
                v4.close();
                if (v0_5.length() > v8) {
                    v0_5 = v0_5.substring(0, 1024);
                }

                JSONObject v4_1 = new JSONObject();
                v4_1.put("event_type", "exception");
                v4_1.put("timestamp", System.currentTimeMillis());
                v4_1.put("class_ref", v1_1);
                v4_1.put("method", v2_1);
                v4_1.put("line_num", v3);
                v4_1.put("stack", v0_5);
                v4_1.put("exception_type", 0);
                v4_1.put("is_core", 1);
//                if (!TextUtils.isEmpty(null)) {
//                    if (null.length() > v8) {
//                        v4_1.put("message", null.substring(0, 1024));
//                    } else {
//                        v4_1.put("message", null);
//                    }
//                }

                com.bytedance.article.common.a.d.c.a().a("core_exception_monitor", v4_1.toString(), null, true);
            } catch (Throwable v0_2) {
                v0_2.printStackTrace();
            }
        }
    }

    public static void a(Throwable arg4, String arg5) {
        PrintStream v1_3;
        PrintStream v0_3 = null;
        FileOutputStream v2 = null;
        FileOutputStream v1 = null;
        if (arg5 == null) {
            return;
        }

        File v0 = new File(arg5);
        if (v0.exists()) {
            return;
        }

        try {
            v2 = new FileOutputStream(v0);
            v0_3 = new PrintStream(v2);
            v0_3.write("EXCE".getBytes());
            arg4.printStackTrace(v0_3);
        } catch (Exception v1_2) {

        } finally {
            if (v0_3 != null) {
                v0_3.close();
            }

            if (v2 != null) {
                try {
                    v2.close();
                } catch (Exception v1_2) {
                    v1_2.printStackTrace();
                }
            }

            return;
        }
    }


    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public static void a(Map arg3, View arg4) {
        if (arg4.getVisibility() == View.VISIBLE) {
            String v0 = arg4.getTransitionName();
            if (v0 != null) {
                arg3.put(v0, arg4);
            }

            if (!(arg4 instanceof ViewGroup)) {
                return;
            }

            int v1 = ((ViewGroup) arg4).getChildCount();
            int v0_1;
            for (v0_1 = 0; v0_1 < v1; ++v0_1) {
                a(arg3, ((ViewGroup) arg4).getChildAt(v0_1));
            }
        }
    }

    public static void a(ZipFile arg1) {
        if (arg1 != null) {
            try {
                arg1.close();
            } catch (IOException v0) {
            }
        }
    }

    public static void a(JSONObject arg1, String arg2, Object arg3) {
        if (!isTextEmpty(arg2)) {
            try {
                arg1.put(arg2, arg3);
            } catch (JSONException v0) {
                v0.printStackTrace();
            }
        }
    }

    public static void a(boolean arg1) {
        if (!arg1) {
            throw new IllegalArgumentException();
        }
    }

    public static void a(boolean arg1, String arg2) {
        if (P != null && P.get() != null) {
            ((com.ss.android.account.c.c) P.get()).a(arg1, arg2);
        }

        P = null;
    }

    public static boolean a(char arg1) {
        boolean v0 = arg1 == 32 || arg1 == 9 || arg1 == 13 || arg1 == 10 ? true : false;
        return v0;
    }

    public static boolean a(Activity arg1, IWXAPI arg2, String arg3, String arg4) {
        boolean v0_2;
        if (arg1 != null) {
            try {
                if ((arg1 instanceof com.ss.android.account.c.c)) {
                    P = new WeakReference(arg1);
                } else {
                    label_12:
                    P = null;
                }
                Req v0_1 = new Req();
                v0_1.scope = arg3;
                v0_1.state = arg4;
                v0_2 = arg2.sendReq(((BaseReq) v0_1));
            } catch (Exception v0) {
                v0.printStackTrace();
                v0_2 = false;
            }
        } else {
            P = null;
            Req v0_1 = new Req();
            v0_1.scope = arg3;
            v0_1.state = arg4;
            v0_2 = arg2.sendReq(v0_1);
        }

        return v0_2;
    }

    public static boolean a(Context arg7, long arg8, String arg10) {
        boolean v0 = false;
        Intent v1 = b(arg7, arg8, arg10);
        if (v1 == null) {
            Log.w("SsDownloadManager", "No intent built for " + arg8);
            return v0;
        }

        v1.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        try {
            arg7.startActivity(v1);
            v0 = true;
        } catch (Throwable v2) {
            Log.w("SsDownloadManager", "Failed to start " + v1 + ": " + v2);
        }

        return v0;
    }

    public static boolean a(Context arg2, Intent arg3) {
        boolean v0 = false;
        if (arg2 != null) {
            try {
                if (arg3.resolveActivity(arg2.getPackageManager()) == null) {
                    return v0;
                }
            } catch (Throwable v1) {
                return v0;
            }

            v0 = true;
        }

        return v0;
    }

    public static boolean a(Context arg15, String arg16, String arg17, long arg18, boolean arg20) {
        Intent v4_3;
        int v4_2;
        int v3_2;
        String v14;
        String v11;
        String v10;
        String v9;
        String v4;
        Intent v6;
        int v2_2;
        Uri v5;
        boolean v2;
        if (arg15 == null) {
            v2 = false;
            return v2;
        }

        try {
            if (isTextEmpty(arg16)) {
                return false;
            }

            v5 = Uri.parse(arg16);
            v2_2 = 0;
            boolean v3_3;
            if (!TTUtils.isValidUrl(arg16)) {
            } else {
                v2_2 = 1;
                v6 = new Intent(arg15, BrowserActivity.class);
                v6.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                v6.setData(v5);
                v6.putExtra("swipe_mode", 2);
                if (!isTextEmpty(arg17)) {
                    v6.putExtra("bundle_download_app_log_extra", arg17);
                }

                v6.putExtra("ad_id", arg18);
                v6.putExtra("bundle_forbid_jump", arg20);
                if (!(arg15 instanceof Activity)) {
                    v6.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                }

                if (v5 == null) {
                    arg15.startActivity(v6);
                } else {
                    BaseAppData v3 = BaseAppData.inst();
                    Uri v3_1 = !v3.aD() ? v5 : v5.buildUpon().build();
                    v4 = v3_1.getQueryParameter("back_button_color");
                    String v7 = v3_1.getQueryParameter("back_button_icon");
                    String v8 = v3_1.getQueryParameter("back_button_position");
                    v9 = v3_1.getQueryParameter("disableHistory");
                    v10 = v3_1.getQueryParameter("hide_bar");
                    v11 = v3_1.getQueryParameter("hide_nav_bar");
                    String v12 = v3_1.getQueryParameter("title");
                    if (!isTextEmpty(v12)) {
                        v6.putExtra("title", v12);
                    }

                    v12 = v3_1.getQueryParameter("status_bar_color");
                    String v13 = v3_1.getQueryParameter("status_bar_background");
                    v14 = v3_1.getQueryParameter("hide_status_bar");
                    if (!isTextEmpty(v4)) {
                        v6.putExtra("back_button_color", v4);
                    }

                    if (!isTextEmpty(v7)) {
                        v6.putExtra("back_button_icon", v7);
                    }

                    if (!isTextEmpty(v8)) {
                        v6.putExtra("back_button_position", v8);
                    }

                    if (!isTextEmpty(v12)) {
                        v6.putExtra("status_bar_color", v12);
                    }

                    if (!isTextEmpty(v13)) {
                        v6.putExtra("status_bar_background", v13);
                    }

                    if (isTextEmpty(v14)) {
                    } else {
                        v3_2 = Integer.parseInt(v14);
                        if (v3_2 > 0) {
                            v6.putExtra("hide_status_bar", true);
                        }
                    }
                    if (isTextEmpty(v9)) {
                    } else {
                        v3_2 = Integer.parseInt(v9);
                        v4_2 = v3_2;
                        v3_3 = false;
                        if (v4_2 > 0) {
                            v3_3 = true;
                        }
                        v6.putExtra("back_button_disable_history", v3_3);
                    }
                    if (isTextEmpty(v10)) {

                    } else {
                        v3_2 = Integer.parseInt(v10);
                        v4_2 = v3_2;
                        v3_3 = false;
                        if (v4_2 > 0) {
                            v3_3 = true;
                        }
                        v6.putExtra("key_hide_bar", v3_3);
                    }
                    if (isTextEmpty(v11)) {
                    } else {
                        v3_2 = Integer.parseInt(v11);
                        v4_2 = v3_2;
                        v3_3 = false;
                        if (v4_2 > 0) {
                            v3_3 = true;
                        }
                        v6.putExtra("key_hide_bar", v3_3);
                    }
                    if ((("down_arrow".equals(v7))
                            || ("close".equals(v7))) && (("top_left".equals(v8)) || ("top_right".equals(v8)) || (isTextEmpty(v8)))) {
                        v6.putExtra("activity_trans_type", 3);
                    }
                    arg15.startActivity(v6);
                }
            }
            try {
                label_139:
                if (v2_2 != 0) {
                    return true;
                }
                v2_2 = 0;
                v3_3 = AdsAppBaseActivity.c(v5.getScheme());
                v4 = v5.getHost();
                if ((v3_3) && ("webview".equals(v4))) {
                    v2_2 = 1;
                    v4_3 = AdsAppBaseActivity.a(arg15, v5);
                    if (v4_3 != null) {
                        if (!isTextEmpty(arg17)) {
                            v4_3.putExtra("bundle_download_app_log_extra", arg17);
                        }

                        v4_3.putExtra("swipe_mode", 2);
                        if ((arg15 instanceof Activity)) {
                        } else {
                            v4_3.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                        }
                    }
                    arg15.startActivity(v4_3);
                }

                if (v3_3) {
                    v2_2 = 1;
                    Class v3_4 = BaseAppData.inst().ab();
                    if (v3_4 != null) {
                        v4_3 = new Intent(arg15, v3_4);
                        v4_3.setData(v5);
                        v4_3.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                        v4_3.putExtra("is_from_self", true);
                        if (!isTextEmpty(arg17)) {
                            v4_3.putExtra("bundle_download_app_log_extra", arg17);
                        }

                        v4_3.putExtra("ad_id", arg18);
                        if (!(arg15 instanceof Activity)) {
                            v4_3.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                        }

                        arg15.startActivity(v4_3);
                    }
                }

                if (v2_2 != 0) {
                    return true;
                }

                v2_2 = 0;
                Intent v3_5 = new Intent("android.intent.action.VIEW");
                v3_5.setData(v5);
                v3_5.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                if (ToolUtils.isInstalledApp(arg15, v3_5)) {
                    v3_5.putExtra("open_url", arg16);
                    if (!(arg15 instanceof Activity)) {
                        v3_5.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    }

                    arg15.startActivity(v3_5);
                    v2_2 = 1;
                }

                if (v2_2 != 0) {
                    return true;
                }

                v2_2 = 0;
                String v3_6 = v5.getScheme();
                if (v3_6.startsWith("snssdk")) {
                    v4_3 = new Intent("com.ss.android.sdk." + v3_6);
                    if (ToolUtils.isInstalledApp(arg15, v4_3)) {
                        v2_2 = 1;
                        v4_3.putExtra("open_url", arg16);
                        if (!(arg15 instanceof Activity)) {
                            v4_3.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                        }

                        arg15.startActivity(v4_3);
                    }
                }
            } catch (Exception v2_1) {
                v2_1.printStackTrace();
                return false;
            }
        } catch (Exception v2_1) {
            return false;
        }

        if (v2_2 != 0) {
            v2 = true;
        } else {
            v2 = false;
        }
        return v2;
    }

    public static boolean a(ContextWrapper arg12, Intent arg13, ServiceConnection arg14) {
        Method v2;
        Method v3;
        Object v7;
        Context v5 = arg12.getBaseContext();
        if (arg14 == null) {
            throw new IllegalArgumentException("connection is null");
        }

        Object v0 = d(v5, "mPackageInfo");
        if (v0 == null) {
            throw new RuntimeException("Not supported in system context");
        }

        Object v6 = a(v0, "getServiceDispatcher", new Class[]{ServiceConnection.class, Context.class, Handler.class, Integer.TYPE}, new Object[]{arg14, arg12, null, Integer.valueOf(1)});
        try {
            v0 = b(v5, "getActivityToken");
            if (Build.VERSION.SDK_INT >= 18) {
                if (b(arg13.getClass(), "prepareToLeaveProcess", new Class[0]) != null) {
                    b(arg13, "prepareToLeaveProcess");
                }
            } else if (b(arg13, "setAllowFds", new Class[]{Boolean.class}) != null) {
                a(arg13, "setAllowFds", new Class[]{Boolean.class}, new Object[]{Boolean.valueOf(false)});
            }

            v7 = b(Class.forName("android.app.ActivityManagerNative"), "getDefault", new Class[0]).invoke(null);
            if (v7 == null) {
                throw new RuntimeException("avtivityManager object is null");
            }

            v3 = null;
            Class[] v1 = null;
            Method[] v8 = v7.getClass().getDeclaredMethods();
            int v9 = v8.length;
            int v4 = 0;
            while (true) {
                if (v4 < v9) {
                    v2 = v8[v4];
                    if (v2.getName().equals("bindService")) {
                        v1 = v2.getParameterTypes();
                    } else {
                        ++v4;
                        continue;
                    }
                } else {
                    v2 = v3;
                    break;
                }
                break;
            }
            if (v2 == null) {
                throw new RuntimeException("bindService method is null.");
            }

            Integer.valueOf(-1);
            if (v1.length == 6) {
                v0 = v2.invoke(v7, g(v5), v0, arg13, arg13.resolveTypeIfNeeded(v5.getContentResolver()), v6, Integer.valueOf(1));
            } else if (v1.length == 7) {
                v0 = v2.invoke(v7, g(v5), v0, arg13, arg13.resolveTypeIfNeeded(v5.getContentResolver()), v6, Integer.valueOf(1), Integer.valueOf(F()));
            } else if (v1.length == 8) {
                v0 = v2.invoke(v7, g(v5), v0, arg13, arg13.resolveTypeIfNeeded(v5.getContentResolver()), v6, Integer.valueOf(1), b(v5, "getOpPackageName"), Integer.valueOf(F()));
            } else {
                throw new RuntimeException("bindService parameter is error.");
            }

            int v1_1 = ((Integer) v0).intValue();
            if (v1_1 < 0) {
                throw new RuntimeException("bindService is error.ret:" + v0);
            }

            if (((Integer) v0).intValue() != 0) {
            } else {
                return false;
            }
        } catch (Exception v0_1) {
            v0_1.printStackTrace();
            throw new RuntimeException(v0_1.getMessage());
        }

        boolean v0_2 = true;
        return v0_2;
    }

    public static boolean a(DrawableContainer arg7, Drawable.ConstantState arg8) {
        boolean v0 = true;
        if (!G) {
            try {
                Method v2_1 = DrawableContainer.class.getDeclaredMethod("setConstantState", DrawableContainer.DrawableContainerState.class);
                F = v2_1;
                v2_1.setAccessible(true);
            } catch (NoSuchMethodException v2) {
                Log.e("DrawableUtils", "Could not fetch setConstantState(). Oh well.");
            }

            G = true;
        }

        if (F != null) {
            try {
                F.invoke(arg7, arg8);
                return v0;
            } catch (Exception v0_1) {
                Log.e("DrawableUtils", "Could not invoke setConstantState(). Oh well.");
            }
        }

        return false;
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public static boolean a(ViewParent arg4, View arg5, float arg6, float arg7) {
        boolean v0_1;
        try {
            v0_1 = arg4.onNestedPreFling(arg5, arg6, arg7);
        } catch (AbstractMethodError v0) {
            Log.e("ViewParentCompat", "ViewParent " + arg4 + " does not implement interface method onNestedPreFling", ((Throwable) v0));
            v0_1 = false;
        }

        return v0_1;
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public static boolean a(ViewParent arg4, View arg5, float arg6, float arg7, boolean arg8) {
        boolean v0_1;
        try {
            v0_1 = arg4.onNestedFling(arg5, arg6, arg7, arg8);
        } catch (AbstractMethodError v0) {
            Log.e("ViewParentCompat", "ViewParent " + arg4 + " does not implement interface method onNestedFling", ((Throwable) v0));
            v0_1 = false;
        }

        return v0_1;
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public static boolean a(ViewParent arg4, View arg5, View arg6, int arg7) {
        boolean v0_1;
        try {
            v0_1 = arg4.onStartNestedScroll(arg5, arg6, arg7);
        } catch (AbstractMethodError v0) {
            Log.e("ViewParentCompat", "ViewParent " + arg4 + " does not implement interface method onStartNestedScroll", ((Throwable) v0));
            v0_1 = false;
        }

        return v0_1;
    }

    public static boolean a(com.ss.android.newmedia.message.h arg10, Intent arg11) {
        Context v1_1;
        try {
            BaseAppData v0_1 = BaseAppData.inst();
            Activity v2 = v0_1.aO();
            if (v2 == null) {
                return false;
            }

            if ((v2 instanceof AbsSplashActivity)) {
                return false;
            }

            AlertManager v0_2 = v0_1.mAlertManager;
            if (com.ss.android.newmedia.message.dialog.w.a(((Context) v2)).c) {
                if (!v0_2.a()) {
                    String v1 = arg10.e;
                    String v3 = arg10.d;
                    int v4 = arg10.i;
                    Context v5 = v2.getApplicationContext();
                    t v6 = new t(((Context) v2));
                    v6.b = v1;
                    v6.c = v3;
                    v6.setOnShowListener(new com.ss.android.newmedia.message.dialog.p());
                    v6.setOnDismissListener(new com.ss.android.newmedia.message.dialog.q());
                    v6.a = new com.ss.android.newmedia.message.dialog.r(v5, arg11, v4);
                    v0_2.a(((Dialog) v6));
                    ((Dialog) v6).show();
                    com.ss.android.newmedia.message.i.a(v2.getApplicationContext(), "news_alert_show", ((long) arg10.i), -1, false, new JSONObject[0]);
                    boolean v0_3 = true;
                    return v0_3;
                }

                return false;
            }

            if (arg10.t.a.a) {
                if (v0_2.a()) {
                    return false;
                }

                if (com.ss.android.newmedia.message.dialog.a.b()) {
                    return false;
                }

                v1_1 = v2.getApplicationContext();
                x v3_1 = new x(((Context) v2));
                v3_1.b = arg10.d;
                v3_1.setCanceledOnTouchOutside(false);
                v3_1.c = arg10.f;
                v3_1.setOnShowListener(new com.ss.android.newmedia.message.dialog.n());
                v3_1.setOnDismissListener(new com.ss.android.newmedia.message.dialog.o());
                v3_1.a(new s(v1_1, arg10, arg11));
                v0_2.a(((Dialog) v3_1));
                ((Dialog) v3_1).show();
                com.ss.android.newmedia.message.i.a(v2.getApplicationContext(), "news_alert_show", ((long) arg10.i), 1, false, new JSONObject[0]);
                return true;
            }

            if (com.ss.android.newmedia.message.dialog.a.b()) {
                return false;
            }

            if (v0_2.a()) {
                return false;
            }

            if (!com.ss.android.newmedia.message.dialog.w.a(((Context) v2)).b) {
                return false;
            }

            View v3_2 = LayoutInflater.from(v2).inflate(com.ss.android.article.browser.R.layout.ag, null);
            View v4_1 = v3_2.findViewById(com.ss.android.article.browser.R.id.j6);
            View v0_4 = v3_2.findViewById(com.ss.android.article.browser.R.id.j5);
            View v5_1 = v3_2.findViewById(com.ss.android.article.browser.R.id.j4);
            ((TextView) v3_2.findViewById(com.ss.android.article.browser.R.id.content)).setText(arg10.d);
            ((ImageView) v0_4).setImageDrawable(VectorDrawableCompat.create(v2.getResources(), com.ss.android.article.browser.R.drawable.fp, null));
            v0_4 = v3_2.findViewById(com.ss.android.article.browser.R.id.image);
            if (TextUtils.isEmpty(arg10.f)) {
                ((AsyncImageView) v0_4).setVisibility(View.GONE);
            } else {
                ((AsyncImageView) v0_4).setVisibility(View.VISIBLE);
                ((AsyncImageView) v0_4).setUrl(arg10.f);
            }

            com.ss.android.newmedia.message.dialog.a v0_5 = new com.ss.android.newmedia.message.dialog.a(v2, v3_2);
            v1_1 = v2.getApplicationContext();
            v4_1.setOnClickListener(new com.ss.android.newmedia.message.dialog.k(v0_5, v1_1, arg10));
            v5_1.setOnClickListener(new com.ss.android.newmedia.message.dialog.l(v0_5, v1_1, arg10, arg11));
            v0_5.a = new com.ss.android.newmedia.message.dialog.m(v1_1, arg10, v2);
            if (!v0_5.a()) {
                return false;
            }

            com.ss.android.newmedia.message.i.a(v2.getApplicationContext(), "news_alert_show", ((long) arg10.i), 2, false, new JSONObject[0]);
            return true;
        } catch (Exception v0) {
            v0.printStackTrace();
            return false;
        }
    }

    public static boolean readInputStream(InputStream inputStream,
                                          long contentLenght,
                                          com.bytedance.frameworks.baselib.network.http.f arg22,
                                          int maxLenght,
                                          String directory,
                                          String arg25,
                                          String arg26,
                                          com.bytedance.frameworks.baselib.network.http.util.d arg27,
                                          String arg28,
                                          TaskInfo taskInfo) throws Exception {
        RandomAccessFile v6_3;
        FileOutputStream v5_3 = null;
        Closeable v5_2;
        int v5_1;
        long v6_1;
        int v4_6;
        byte[] v12;
        long v4_5;
        RandomAccessFile v9 = null;
        Closeable v10 = null;
        Closeable v6 = null;
        File v5 = null;
        if (inputStream == null) {
            return false;
        }

        if (contentLenght > 2147483647) {
            Logger.w("NetworkUtils", "HTTP entity too large");
            throw new DownloadFileTooLargeException(maxLenght, 2147483647);
        }

        if (contentLenght < 0) {
            contentLenght = 4096;
        } else if (maxLenght > 0 && contentLenght > (long) maxLenght) {
            Logger.w("NetworkUtils", "entity length exceed given maxLength");
            throw new DownloadFileTooLargeException(maxLenght, contentLenght);
        }
        File dir = new File(directory);
        if (!dir.exists()) {
            dir.mkdirs();
        }

        File tmpFile;
        try {
            tmpFile = File.createTempFile("tempimage", ".tmp", new File(directory));
        } catch (IOException ioException) {
            if (!isTextEmpty(arg25) && !arg25.equals(directory)) {
                dir = new File(arg25);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                tmpFile = File.createTempFile("tempimage", ".tmp", new File(arg25));
                directory = arg25;
            } else {
                tmpFile = v5;
                throw ioException;
            }
        }

        if (tmpFile == null) {
            return false;
        }

        try {
            v9 = new RandomAccessFile(tmpFile, "rw");
            v4_5 = 0;
            v9.setLength(v4_5);
            v12 = new byte[4096];
            v4_6 = 0;
            v6_1 = 0;
            while (true) {
                v5_1 = inputStream.read(v12);
                if (v5_1 == -1) {
                    break;
                }

                if (taskInfo != null && (taskInfo.a)) {
                    URI v4_7 = arg22.a();
                    arg22.b();
                    Logger.v("NetworkUtils", "download file canceled " + v4_7);
                    v9.close();
                    closeQuietly(inputStream, "close instream exception ");
                    closeQuietly(null, "close outstream exception ");
                    closeQuietly(null, "close random file exception ");
                    if (tmpFile != null) {
                        try {
                            tmpFile.delete();
                        } catch (Exception v4_2) {
                            Logger.d("NetworkUtils", "delete temp file exception " + v4_2);
                        }
                        return false;
                    } else {
                        return false;
                    }
                }
                int v11 = v4_6 + v5_1;
                if (maxLenght > 0 && v11 > maxLenght) {
                    Logger.w("NetworkUtils", "entity length did exceed given maxLength");
                    v9.close();
                    v5_2 = null;
                    throw new DownloadFileTooLargeException(maxLenght, contentLenght);
                }

                v9.write(v12, 0, v5_1);
                if (arg27 != null && arg28 != null) {
                    v4_5 = System.currentTimeMillis();
                    if (v4_5 - v6_1 >= 500) {
                        int v6_2 = contentLenght >= (((long) v11)) ? ((int) ((((long) (v11 * 100))) / contentLenght)) : 80;
                        if (v6_2 >= 99) {
                            v6_2 = 99;
                        }

                        arg27.a(v6_2, arg28);
                    } else {
                        v4_5 = v6_1;
                    }

                    v6_1 = v4_5;
                    v4_6 = v11;
                } else {
                    v4_6 = v11;
                }
                continue;
            }
            if (v4_6 > 0) {
                v9.seek(0);
                v5_3 = new FileOutputStream(new File(directory, arg26));
                while (true) {
                    v4_6 = v9.read(v12);
                    if (v4_6 == -1) {
                        return true;
                    }
                    ((OutputStream) v5_3).write(v12, 0, v4_6);
                }
            }
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                    inputStream = null;
                } catch (Exception e) {

                }
            }

            if (tmpFile != null) {
                try {
                    tmpFile.delete();
                    tmpFile = null;
                } catch (Exception e) {

                }
            }

            if (v5_3 != null) {
                try {
                    v5_3.close();
                    v5_3 = null;
                } catch (Exception e) {

                }
            }
            if (v9 != null) {
                try {
                    v9.close();
                    v9 = null;
                } catch (Exception e) {

                }
            }

            if (arg22 != null) {
                try {
                    arg22.b();
                } catch (Exception e) {

                }
            }
        }
        return false;
    }

    public static boolean isTelephoneNo(CharSequence input) {
        return !TextUtils.isEmpty(input) && Pattern.compile("^((\\+86)|(86))?(1\\d{10})$").matcher(input).matches();
    }

    public static boolean onPull(Object arg1, float arg2) {
        ((EdgeEffect) arg1).onPull(arg2);
        return true;
    }

    public static boolean a(Object arg1, Object arg2) {
        boolean v0;
        if (arg1 != null) {
            v0 = arg1.equals(arg2);
        } else if (arg2 == null) {
            v0 = true;
        } else {
            v0 = false;
        }

        return v0;
    }

    public static boolean isEmptyCollection(Collection collection) {
        return collection == null || (collection.isEmpty());
    }

    public static boolean a(List<ResolveInfo> resolveInfoList, Context context) {
        return TextUtils.equals(context.getPackageName(), resolveInfoList.get(0).activityInfo.packageName);
    }

    public static boolean a(byte[] arg6, String arg7, String arg8) {
        FileOutputStream v3 = null;
        boolean v0 = false;
        FileOutputStream v2 = null;
        try {
            File v1_1 = new File(arg7);
            if (!v1_1.exists() && !v1_1.mkdirs() && !v1_1.exists()) {
                return v0;
            }

            v3 = new FileOutputStream(new File(v1_1, arg8));
            v3.write(arg6);
            v3.flush();
            return true;
        } catch (Exception v1) {
            Logger.d("BitmapUtils", "save image exception " + v1);
        } finally {
            try {
                v3.close();
            } catch (Exception v1) {
            }
        }
        return v0;
    }

    public static byte[] a(Context arg7, String arg8, boolean arg9) {
        Bitmap v3;
        ByteArrayOutputStream v2_1 = null;
        Throwable v0_1;
        Bitmap v2;
        Canvas v1_3;
        Bitmap v4;
        byte[] v0 = null;
        if ((TextUtils.isEmpty(((CharSequence) arg8))) && !arg9) {
            return v0;
        }

        if (!TextUtils.isEmpty(((CharSequence) arg8)) || !arg9) {
            File v1 = FrescoUtils.tryGetCacheFile(Uri.parse(arg8));
            if (v1 != null) {
                v4 = BitmapDemo.b(v1.getAbsolutePath());
            } else {
                v4 = E(arg7);
            }
        } else {
            v4 = E(arg7);
        }

        if (v4 == null) {
            return v0;
        }

        if (arg9) {
            v1_3 = new Canvas(v4);
            v2 = BitmapFactory.decodeResource(arg7.getApplicationContext().getResources(), com.ss.android.article.browser.R.drawable.f);
            if (v2 == null) {
            } else {
                v1_3.drawBitmap(v2, ((float) ((v4.getWidth() - v2.getWidth()) / 2)), ((float) ((v4.getHeight() - v2.getHeight()) / 2)), null);
            }
            v3 = v2;
        } else {
            v3 = ((Bitmap) null);
        }

        try {
            v2_1 = new ByteArrayOutputStream();
            v4.compress(Bitmap.CompressFormat.JPEG, 85, ((OutputStream) v2_1));
            v0 = v2_1.toByteArray();
        } catch (Exception v1_2) {
            Logger.throwExceptionInDebug(((Throwable) v1_2));
        } finally {
            if (v2_1 != null) {
                try {
                    v2_1.close();
                } catch (IOException v1_4) {
                }
            }

            if (v4 != null) {
                v4.recycle();
            }
        }
        return v0;
    }

    public static byte[] a(Context arg7, byte[] arg8, boolean arg9) {
        Bitmap v3;
        ByteArrayOutputStream v2_1 = null;
        Throwable v0_1;
        Bitmap v2;
        Canvas v1_2;
        byte[] v0 = null;
        if (arg8 == null) {
            return v0;
        }

        Bitmap v4 = BitmapFactory.decodeByteArray(arg8, 0, arg8.length);
        if (v4 == null) {
            return v0;
        }

        if (arg9) {
            v1_2 = new Canvas(v4);
            v2 = BitmapFactory.decodeResource(arg7.getApplicationContext().getResources(), com.ss.android.article.browser.R.drawable.f);
            if (v2 == null) {
            } else {
                v1_2.drawBitmap(v2, ((float) ((v4.getWidth() - v2.getWidth()) / 2)), ((float) ((v4.getHeight() - v2.getHeight()) / 2)), null);
            }
            v3 = v2;
        } else {
            v3 = null;
        }

        try {
            v2_1 = new ByteArrayOutputStream();
            v4.compress(Bitmap.CompressFormat.JPEG, 85, ((OutputStream) v2_1));
            v0 = v2_1.toByteArray();
        } catch (Exception v1_1) {
            Logger.throwExceptionInDebug(v1_1);
        } finally {
            if (v2_1 != null) {
                try {
                    v2_1.close();
                } catch (IOException v1_3) {
                }
            }

            if (v4 != null) {
                v4.recycle();
            }
        }


        return v0;
    }

    public static byte[] a(InputStream arg5) {
        ByteArrayOutputStream v2 = null;
        byte[] v0 = null;
        if (arg5 == null) {
            return v0;
        }

        try {
            v2 = new ByteArrayOutputStream(512 * 1024);
            a(arg5, v2);
            v0 = v2.toByteArray();
            c(v2);
            return v0;
        } catch (IOException v1_1) {
            try {
                Logger.e("FileUtils", "catch", v1_1);
            } catch (Throwable throwable) {
            }
            return v0;
        } finally {
            c(v2);
        }
    }

    public static byte[] a(String arg6, byte[] arg7, launchNetUtils$CompressType arg8, String arg9) throws Throwable {
        String v0_2 = null;
        int v5 = 128;
        byte[] v0 = null;
        int v3 = 8192;
        if (arg6 != null) {
            if (arg7 == null) {
                arg7 = new byte[0];
            }

            int v1 = arg7.length;
            if (launchNetUtils$CompressType.GZIP == arg8 && v1 > v5) {
                ByteArrayOutputStream v1_1 = new ByteArrayOutputStream(v3);
                GZIPOutputStream v2 = new GZIPOutputStream(((OutputStream) v1_1));
                try {
                    v2.write(arg7);
                } catch (Throwable v1_2) {
                    return v0;
                } finally {
                    v2.close();
                }
                arg7 = v1_1.toByteArray();
                v0_2 = "gzip";
            } else if (launchNetUtils$CompressType.DEFLATER == arg8 && v1 > v5) {
                ByteArrayOutputStream v0_3 = new ByteArrayOutputStream(v3);
                Deflater v1_3 = new Deflater();
                v1_3.setInput(arg7);
                v1_3.finish();
                byte[] v2_1 = new byte[v3];
                while (!v1_3.finished()) {
                    v0_3.write(v2_1, 0, v1_3.deflate(v2_1));
                }

                v1_3.end();
                arg7 = v0_3.toByteArray();
                v0_2 = "deflate";
            }

            byte[] v1_4 = TTEncryptUtils.encryptBytes(arg7, arg7.length);
            if (v1_4 != null) {
                arg6 = arg6 + "&tt_data=a";
                arg9 = "application/octet-stream;tt-data=a";
                arg7 = v1_4;
            }

            v0 = a(arg6, arg7, arg9, v0_2, "POST");
        }

        return v0;
    }

    private static byte[] a(String arg4, byte[] arg5, String arg6, String arg7, String arg8) throws Throwable {
        byte[] v0_3;
        try {
            LinkedList v1 = new LinkedList();
            URLConnection v0_1 = new URL(UrlDemo.a(arg4, ((List) v1))).openConnection();
            if (!((List) v1).isEmpty()) {
                Iterator v3 = ((List) v1).iterator();
                while (v3.hasNext()) {
                    Pair<String, String> v1_1 = (Pair) v3.next();
                    if (v1_1 == null) {
                        continue;
                    }

                    ((HttpURLConnection) v0_1).setRequestProperty(v1_1.first, v1_1.second);
                }
            }

            v0_1.setDoOutput(true);
            if (arg6 != null) {
                v0_1.setRequestProperty("Content-Type", arg6);
            }

            if (arg7 != null) {
                v0_1.setRequestProperty("Content-Encoding", arg7);
            }

            v0_1.setRequestProperty("Accept-Encoding", "gzip");
            ((HttpURLConnection) v0_1).setRequestMethod(arg8);
            if (arg5 != null && arg5.length > 0) {
                DataOutputStream v1_2 = new DataOutputStream(((HttpURLConnection) v0_1).getOutputStream());
                v1_2.write(arg5);
                v1_2.flush();
                v1_2.close();
            }

            if (((HttpURLConnection) v0_1).getResponseCode() == 200) {
                InputStream v1_3 = v0_1.getInputStream();
                String v0_2 = v0_1.getContentEncoding();
                if ((TextUtils.isEmpty(v0_2)) || !v0_2.equalsIgnoreCase("gzip")) {
                    v0_3 = b(v1_3);
                } else {
                    GZIPInputStream v2 = new GZIPInputStream(v1_3);
                    v0_3 = b(((InputStream) v2));
                    v2.close();
                }

                if (v1_3 != null) {
                    v1_3.close();
                }

                return v0_3;
            }

            throw new RuntimeException(((HttpURLConnection) v0_1).getResponseMessage());
        } catch (Throwable v0) {
            throw v0;
        }
    }

    public static byte[] unzipStream(boolean gzip, int maxLength, InputStream inputStream, int[] lengthOut) throws IOException {
        maxLength = maxLength <= 0 ? 5242880 : maxLength;
        maxLength = maxLength < 1024 * 1024 ? 1024 * 1024 : maxLength;
        if (inputStream == null) {
            return null;
        }

        if (gzip) {
            try {
                inputStream = new GZIPInputStream(inputStream);
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
        }

        int off = 0;
        byte[] bytes = new byte[8192];
        do {
            int capacity_test_val = off + 4096;
            try {
                if (capacity_test_val > bytes.length) {
                    byte[] newBytes = new byte[bytes.length << 1];
                    System.arraycopy(bytes, 0, newBytes, 0, off);
                    bytes = newBytes;
                }
                int readLength = inputStream.read(bytes, off, 4096);
                if (readLength <= 0) {
                    if (off > 0) {
                        lengthOut[0] = off;
                        closeQuietly(inputStream, ((String) null));
                        return bytes;
                    } else {
                        closeQuietly(inputStream, ((String) null));
                        return null;
                    }
                }

                off += readLength;
                if (maxLength <= 0) {
                    continue;
                }
                if (off <= maxLength) {
                    continue;
                }
                Logger.w("NetworkUtils", "entity length did exceed given maxLength");
                closeQuietly(inputStream, null);
                return null;
            } catch (IOException ioe) {
                try {
                    String message = ioe.getMessage();
                    if (gzip
                            && off > 0
                            && (("CRC mismatch".equals(message)) || ("Size mismatch".equals(message)))) {
                        Logger.w("NetworkUtils", "ungzip got exception " + ioe);
                        if (off > 0) {
                            lengthOut[0] = off;
                            closeQuietly(inputStream, null);
                            return bytes;
                        } else {
                            closeQuietly(inputStream, null);
                        }
                    }
                } catch (Throwable throwable) {
                    throwable.printStackTrace();
                }
                return null;
            }
        } while (true);
    }

    @NonNull
    public static o b() {
        if (N == null) {
            N = new com.a.a.ab(Looper.getMainLooper());
        }

        return N;
    }

    public static void b(View view, int tagLayoutId) {
        view.setTag(com.ss.android.article.browser.R.id.tag_layout_id, Integer.valueOf(tagLayoutId));
    }

    public static boolean isTextEquals(String left, String right) {
        boolean v0;
        if (!isTextEmpty(left) || !isTextEmpty(right)) {
            if (left != null && (left.equals(right))) {
                return true;
            } else {
                return false;
            }
        } else {
            return true;
        }
    }

    public static void b(Map arg1) {
        if (arg1 != null) {
            if (Q != null && Q.get() == arg1) {
                return;
            }

            Q = new WeakReference(arg1);
        } else {
            if (Q == null) {
                return;
            }

            Q.clear();
        }
    }

    public static boolean isWifi(Context context) {
        try {
            NetworkInfo networkInfo = ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
            if (networkInfo == null || !networkInfo.isAvailable()) {
                return false;
            }

            if (1 != networkInfo.getType()) {
                return false;
            }
        } catch (Exception v0) {
            return false;
        }

        return true;
    }

    private static Method b(Class arg1, String arg2, Class[] arg3) {
        Method v0_1;
        while (true) {
            if (arg1 != Object.class) {
                try {
                    v0_1 = arg1.getDeclaredMethod(arg2, arg3);
                    return v0_1;
                } catch (Exception v0) {
                    v0.printStackTrace();
                    arg1 = arg1.getSuperclass();
                    continue;
                }
            } else {
                return null;
            }
        }
    }

    private static Object b(Object arg3, String arg4) {
        Object v0_4;
        Method v0 = b(arg3, arg4, new Class[0]);
        if (v0 != null) {
            try {
                v0.setAccessible(true);
                v0_4 = v0.invoke(arg3);
            } catch (InvocationTargetException v0_1) {
                Throwable v1 = v0_1.getTargetException();
                if (v1 != null) {
                    System.out.print(v1.getMessage());
                }

                v0_1.printStackTrace();
                throw new RuntimeException(v0_1.getMessage());
            } catch (IllegalAccessException v0_2) {
                v0_2.printStackTrace();
                throw new RuntimeException(v0_2.getMessage());
            } catch (IllegalArgumentException v0_3) {
                v0_3.printStackTrace();
                throw new RuntimeException(v0_3.getMessage());
            }
        } else {
            v0_4 = null;
        }

        return v0_4;
    }


    private static Method b(Object arg2, String arg3, Class[] arg4) {
        Method v0_1;
        Class v0 = arg2.getClass();
        while (true) {
            if (v0 != Object.class) {
                try {
                    v0_1 = v0.getDeclaredMethod(arg3, arg4);
                    return v0_1;
                } catch (Exception v1) {
                    v1.printStackTrace();
                    v0 = v0.getSuperclass();
                    continue;
                }
            } else {
                return null;
            }
        }
    }

    private static void b(InputStream arg6, OutputStream arg7) throws Exception {
        int v5 = 10240;
        GZIPOutputStream v0 = new GZIPOutputStream(arg7);
        byte[] v1 = new byte[v5];
        while (true) {
            int v2 = arg6.read(v1, 0, v5);
            if (v2 == -1) {
                break;
            }

            v0.write(v1, 0, v2);
        }

        v0.flush();
        v0.finish();
        v0.close();
    }

    public static void b(String arg1, JSONObject arg2) {
        if (com.bytedance.framwork.core.a.c.a() != null && !TextUtils.isEmpty(((CharSequence) arg1)) && arg2 != null && arg2.length() > 0) {
            try {
                arg2.put("log_type", arg1);
                if (arg2 == null) {
                    return;
                }

                if (TextUtils.isEmpty(((CharSequence) arg1))) {
                    return;
                }

                try {
                    com.bytedance.frameworks.core.thread.c.a();
                    com.bytedance.frameworks.core.thread.c.a(new com.bytedance.framwork.core.a.a(arg1, arg2));
                } catch (Throwable v0_1) {
                }
            } catch (JSONException v0) {
            }
        }
    }

    public static int b(Context arg2, int arg3) {
        int v1 = com.ss.android.article.browser.R.color.l8;
        int v0 = com.ss.android.article.browser.R.color.lh;
        if (arg2 == null) {
            Logger.throwException("context is null!!!");
            v0 = 0;
        } else {
            switch (arg3) {
                case 2: {
                    v0 = com.ss.android.article.browser.R.color.lf;
                    break;
                }
                case 3: {
                    v0 = v1;
                    break;
                }
                case 4: {
                    v0 = com.ss.android.article.browser.R.color.l_;
                    break;
                }
                case 5: {
                    v0 = com.ss.android.article.browser.R.color.l6;
                    break;
                }
                case 6: {
                    v0 = v1;
                    break;
                }
                case 7: {
                    v0 = com.ss.android.article.browser.R.color.l4;
                    break;
                }
                case 8: {
                    v0 = com.ss.android.article.browser.R.color.lb;
                    break;
                }
                case 1:
                case 10:
                case 11:
                case 12: {
                    break;
                }
                default: {
                    v0 = com.ss.android.article.browser.R.color.ld;
                    break;
                }
            }

            AppData.getInstance();
            AppData.isNightMode();
            v0 = ContextCompat.getColor(arg2, v0);
        }

        return v0;
    }


    public static void b(String arg4, int arg5, JSONObject arg6, JSONObject arg7) {
        try {
            if (!n(arg4)) {
                return;
            }

            com.bytedance.framwork.core.monitor.c.j();
            if (!com.bytedance.framwork.core.monitor.c.k()) {
                return;
            }

            if (e() == null) {
                return;
            }
        } catch (Throwable v0) {
            return;
        }

        try {

            if (arg7 == null) {
                arg7 = new JSONObject();
            }
            label_10:
            arg7.put("log_type", "service_monitor");
            arg7.put("service", arg4);
            arg7.put("status", arg5);
            arg7.put("network_type", C());
            arg7.put("value", arg6);
            arg7.put("timestamp", System.currentTimeMillis());
            e().a("service_monitor", arg7.toString());
        } catch (Throwable v0) {
        }
    }


    private static Intent b(Context arg7, long arg8, String arg10) {
        com.ss.android.common.download.g v2_2;
        String v2_1;
        Intent v0 = null;
        com.ss.android.download.e v1 = com.ss.android.download.e.a(arg7);
        com.ss.android.download.e.b v2 = new com.ss.android.download.e.b();
        v2.a = new long[]{arg8};
        Cursor v1_1 = v1.a(v2);
        try {
            if (v1_1.moveToFirst()) {
                v2_1 = v1_1.getString(v1_1.getColumnIndexOrThrow("local_filename"));
                if (!isTextEmpty(v2_1)) {
                    if (o().a(arg7, v2_1)) {
                        PackageManager v0_2 = arg7.getPackageManager();
                        v0 = v0_2.getLaunchIntentForPackage(v0_2.getPackageArchiveInfo(new File(v2_1).getAbsolutePath(), PackageManager.GET_ACTIVITIES).packageName);
                        v2_2 = v;
                        if (v2_2 != null) {
                            v2_2.a(arg8, 2);
                        }
                    } else {
                        if (!isTextEmpty(arg10) && (o().b(arg7, arg10))) {
                            v0 = arg7.getPackageManager().getLaunchIntentForPackage(arg10);
                            v2_2 = v;
                            if (v2_2 != null) {
                                v2_2.a(arg8, 2);
                            }
                        } else {
                            Uri v3 = d(v1_1, "local_uri");
                            String v4 = c(v1_1, "media_type");
                            if (v3 != null && v4 != null && (new File(v2_1).exists())) {
                                v0 = new Intent("android.intent.action.VIEW");
                                if ("application/vnd.android.package-archive".equals(v4)) {
                                    v0.setDataAndType(v3, v4);
                                } else if ("file".equals(v3.getScheme())) {
                                    v0.setDataAndType(v3, v4);
                                } else {
                                    v0.setDataAndType(v3, v4);
                                }
                                v2_2 = v;
                                if (v2_2 == null) {
                                } else {
                                    v2_2.a(arg8, 3);
                                }
                            }
                        }
                    }
                }
            }
        } catch (Throwable v0_1) {

        } finally {
            if (v1_1 == null) {
                return v0;
            }
            try {
                v1_1.close();
            } catch (Exception v1_2) {
            }
        }
        return v0;
    }

    public static boolean b(long arg4) {
        return (arg4 & 64) == 64;
    }

    private static byte[] b(InputStream arg4) throws IOException {
        ByteArrayOutputStream v0 = new ByteArrayOutputStream();
        byte[] v1 = new byte[8192];
        while (true) {
            int v3 = arg4.read(v1);
            if (-1 == v3) {
                break;
            }

            v0.write(v1, 0, v3);
        }

        if (arg4 != null) {
            arg4.close();
        }

        return v0.toByteArray();
    }

    public static int b(int arg0, int arg1) {
        return arg1;
    }

    public static int b(View arg3) {
        if (!K) {
            try {
                Field v0_1 = View.class.getDeclaredField("mMinWidth");
                J = v0_1;
                v0_1.setAccessible(true);
            } catch (NoSuchFieldException v0) {
            }

            K = true;
        }

        if (J != null) {
            try {
                int v0_3 = ((Integer) J.get(arg3)).intValue();
                return v0_3;
            } catch (Exception v0_2) {
            }
        }

        return 0;
    }

    public static long b(Cursor arg2, String arg3) {
        long v0_1;
        if (arg2 != null) {
            int v0 = arg2.getColumnIndex(arg3);
            if (v0 >= 0) {
                v0_1 = arg2.getLong(v0);
            } else {
                v0_1 = 0;
            }
        } else {
            label_5:
            v0_1 = 0;
        }

        return v0_1;
    }

    public static View b(ViewGroup container, int layoutResId) {
        View view = createInterceptLayoutInflater(container.getContext()).inflate(layoutResId, container, false);
        b(view, layoutResId);
        return view;
    }

    public static String b(Throwable arg4) {
        PrintWriter v2 = null;
        StringWriter v1_1;
        String v0 = null;
        try {
            v1_1 = new StringWriter();
            v2 = new PrintWriter(v1_1);
            arg4.printStackTrace(v2);
            Throwable v3 = arg4.getCause();
            if (v3 != null) {
                v3.printStackTrace(v2);
                v3 = v3.getCause();
                if (v3 != null) {
                    v3.printStackTrace(v2);
                }
            }

            v0 = v1_1.toString();
            return v0;
        } catch (Throwable v0_1) {
            v0_1.printStackTrace();
        } finally {
            try {
                if (v2 != null) {
                    v2.close();
                }
            } catch (Exception e) {

            }
        }
        return null;
    }

    public static List b(String arg6, int arg7) {
        int v0_4;
        JSONArray v3_1;
        ArrayList v0;
        int v1 = 0;
        ArrayList v2 = new ArrayList();
        if (isTextEmpty(arg6)) {
            v0 = v2;
            return v0;
        }

        try {
            UrlBuilder v0_2 = new UrlBuilder(ArticleConstants.articleSearchSugUrl);
            v0_2.addParam("keyword", arg6);
            if (arg7 == 2) {
                v0_2.addParam("from", "media");
            }

            String v0_3 = NetworkUtils.doGet(-1, v0_2.build());
            if (isTextEmpty(v0_3)) {
                v0 = v2;
                return v0;
            }

            JSONObject v3 = new JSONObject(v0_3);
            if (!"success".equals(v3.getString("message"))) {
                v0 = v2;
                return v0;
            }

            v3_1 = v3.optJSONArray("data");
            if (v3_1 != null) {
                v0_4 = v3_1.length();
            } else {
                v0_4 = 0;
            }

            label_37:
            while (v1 < v0_4) {
                ((List) v2).add(v3_1.getJSONObject(v1).optString("keyword"));
                ++v1;
            }
        } catch (Exception v0_1) {
            label_45:
            v0_1.printStackTrace();
        }

        v0 = v2;
        label_6:
        return ((List) v0);
    }

    public static List b(List arg10) {
        Answer v0_2;
        AnswerAbstract v1;
        ArrayList v0;
        Answer v2 = null;
        if (arg10 == null) {
            v0 = new ArrayList();
        } else {
            ArrayList v3 = new ArrayList();
            Iterator v5 = arg10.iterator();
            while (v5.hasNext()) {
                Object v0_1 = v5.next();
                if (v0_1 == null || (isTextEmpty(((AnswerEntity) v0_1).ansid))) {
                    v0_2 = v2;
                } else {
                    Answer v4 = new Answer(((AnswerEntity) v0_1).ansid);
                    v4.mContent = ((AnswerEntity) v0_1).content;
                    v4.mAnsUrl = ((AnswerEntity) v0_1).ans_url;
                    v4.mCreateTime = ((AnswerEntity) v0_1).create_time;
                    v4.mSync.diggCount = ((AnswerEntity) v0_1).digg_count;
                    v4.mSync.isDigg = ((AnswerEntity) v0_1).is_digg;
                    v4.mSync.buryCount = ((AnswerEntity) v0_1).bury_count;
                    v4.mSync.isBury = ((AnswerEntity) v0_1).is_buryed;
                    v4.mIsShowBury = ((AnswerEntity) v0_1).is_show_bury;
                    v4.mSync.readCount = ((AnswerEntity) v0_1).read_count;
                    AbstractEntity v6 = ((AnswerEntity) v0_1).content_abstract;
                    if (v6 == null) {
                        v1 = null;
                    } else {
                        v1 = new AnswerAbstract();
                        v1.mContent = v6.text;
                        if (!isTextEmpty(v1.mContent)) {
                            v1.mContent = v1.mContent.replaceFirst("^\\s*", "").replaceFirst("\\s*$", "");
                        }

                        v1.mLargeImageList = v6.large_image_list;
                        v1.mThumbImageList = v6.thumb_image_list;
                    }

                    v4.mAnswerAbstract = v1;
                    v4.mUser = a(((AnswerEntity) v0_1).user);
                    v4.mShareData = a(((AnswerEntity) v0_1).share_data);
                    v4.mPrivilege = ((AnswerEntity) v0_1).privilege;
                    v4.mSchema = ((AnswerEntity) v0_1).schema;
                    v0_2 = v4;
                }

                if (v0_2 == null) {
                    continue;
                }

                ((List) v3).add(v0_2);
            }

            v0 = v3;
        }

        return ((List) v0);
    }

    public static List b(JSONArray arg6) {
        ArrayList v1 = new ArrayList();
        if (arg6 != null) {
            int v0;
            for (v0 = 0; v0 < arg6.length(); ++v0) {
                JSONObject v2 = arg6.optJSONObject(v0);
                EntryGroup v3 = new EntryGroup();
                v3.id = v2.optLong("id");
                v3.name = v2.optString("name");
                v3.c = d(v2.optJSONArray("list"));
                ((List) v1).add(v3);
            }
        }

        return ((List) v1);
    }

    public static void b(long arg14, long arg16, String arg18, String arg19, String arg20, int arg21, JSONObject arg22) {
        try {
            if (com.bytedance.framwork.core.monitor.c.j() == null) {
                com.bytedance.framwork.core.monitor.a.a().a(new com.bytedance.framwork.core.monitor.a.a$a("api_error", arg14, arg16, arg18, arg19, arg20, arg21, arg22));
                return;
            }

            if (!f()) {
                return;
            }

            com.bytedance.framwork.core.monitor.c v2_1 = com.bytedance.framwork.core.monitor.c.j();
            if (arg18 == null) {
                return;
            }

            if (arg18.length() == 0) {
                return;
            }

            if (v2_1.c == 1) {
                return;
            }

            if (v2_1.a(arg18)) {
                return;
            }

            if (v2_1.e(arg18)) {
                return;
            }

            JSONObject v3 = v2_1.a("api_error", arg14, arg16, arg18, arg19, arg20, arg21);
            com.bytedance.framwork.core.monitor.c.a(v3, arg22);
            if (v3 == null) {
                return;
            }

            if (v3.length() <= 0) {
                return;
            }

            if (v2_1.b == null) {
                return;
            }

            v2_1.b.a("api_error", v3.toString());
        } catch (Throwable v2) {
        }
    }

    public static void b(Context arg3, String arg4, String arg5) {
        if (!TextUtils.isEmpty(((CharSequence) arg4)) && arg3 != null) {
            Intent v0 = new Intent(arg3, BrowserActivity.class);
            v0.putExtra("use_swipe", true);
            v0.putExtra("show_toolbar", true);
            if (!isTextEmpty(arg5)) {
                v0.putExtra("referer", arg5);
            }

            v0.setData(Uri.parse(arg4));
            arg3.startActivity(v0);
        }
    }

    public static void setListImageHolder(ImageView imageView) {
        if (imageView != null) {
            if ((imageView instanceof AsyncImageView)) {
                AsyncImageView aiv = (AsyncImageView) imageView;
                if (aiv.getHierarchy() != null) {
                    GenericDraweeHierarchy draweeHierarchy = (GenericDraweeHierarchy) aiv.getHierarchy();
                    com.ss.android.j.b.isNightModeToggled();
                    draweeHierarchy.setChildDrawableAtIndex(com.ss.android.article.browser.R.drawable.simple_image_holder_listpage);
                }
                aiv.setUrl(null);
            } else {
                com.ss.android.j.b.isNightModeToggled();
                imageView.setImageResource(com.ss.android.article.browser.R.drawable.simple_image_holder_listpage);
            }
        }
    }

    public static void b(TextView arg3, int arg4) {
        int v1;
        int v0 = com.ss.android.article.browser.R.color.q6;
        AppData.getInstance();
        AppData.isNightMode();
        switch (arg4) {
            case 1: {
                v1 = v0;
                break;
            }
            case 2: {
                v1 = com.ss.android.article.browser.R.color.py;
                break;
            }
            case 3: {
                v1 = com.ss.android.article.browser.R.color.q2;
                break;
            }
            case 4: {
                v1 = com.ss.android.article.browser.R.color.q8;
                break;
            }
            case 5: {
                v1 = com.ss.android.article.browser.R.color.q0;
                break;
            }
            case 6: {
                v1 = com.ss.android.article.browser.R.color.q4;
                break;
            }
            default: {
                v1 = v0;
                break;
            }
        }

        ((GradientDrawable) arg3.getBackground()).setColor(ContextCompat.getColor(arg3.getContext(), v1));
    }

    public static void b(Object arg2) {
        if (arg2 == null) {
            throw new NullPointerException("Object must not be null");
        }
    }

    public static void b(String arg2) {
        if (Build.VERSION.SDK_INT >= 18) {
            Trace.beginSection(arg2);
        }
    }

    public static void b(String arg7, String arg8, float arg9) {
        try {
            if (com.bytedance.framwork.core.monitor.c.j() == null) {
                com.bytedance.framwork.core.monitor.a.a().a(new com.bytedance.framwork.core.monitor.a.c(arg7, arg8, arg9, true, "timer"));
                return;
            }

            if (!o(arg7)) {
                return;
            }

            if (e() == null) {
                return;
            }

            if (!f()) {
                return;
            }

            e().c(arg7, arg8, arg9);
        } catch (Throwable v0) {
        }
    }

    public static void b(String arg4, String arg5, String arg6, Callback arg7) {
        HashMap v1 = new HashMap();
        ((Map) v1).put("ansid", arg4);
        ((Map) v1).put("enter_from", arg5);
        if (!isTextEmpty(arg6)) {
            ((Map) v1).put("api_param", arg6);
        }

        Object v0 = com.ss.android.topic.aa.a("http://ib.snssdk.com", IWendaApi.class);
        if (v0 != null) {
            ((IWendaApi) v0).postFormUrl(20480, "/wenda/v1/commit/buryanswer/", v1).enqueue(arg7);
        }
    }

    public static boolean b(Context arg10, String arg11) {
        boolean v0 = true;
        Signature[] v4 = g(arg10, arg11);
        if (v4 != null) {
            Signature[] v5 = D(arg10);
            if (v5 != null) {
                int v6 = v5.length;
                int v3;
                for (v3 = 0; v3 < v6; ++v3) {
                    Signature v7 = v5[v3];
                    int v8 = v4.length;
                    int v2 = 0;
                    while (true) {
                        if (v2 >= v8) {
                            break;
                        } else if (!v7.equals(v4[v2])) {
                            ++v2;
                            continue;
                        }

                        return v0;
                    }
                }

                v0 = false;
            }
        }

        return v0;
    }

    public static boolean b(DrawableContainer arg3, Drawable.ConstantState arg4) {
        boolean v0 = true;
        if (!I) {
            try {
                Field v1_1 = DrawableContainer.class.getDeclaredField("mDrawableContainerStateField");
                H = v1_1;
                v1_1.setAccessible(true);
            } catch (NoSuchFieldException v1) {
                Log.e("DrawableUtils", "Could not fetch mDrawableContainerStateField. Oh well.");
            }

            I = true;
        }

        if (H != null) {
            try {
                H.set(arg3, arg4);
                return v0;
            } catch (Exception v0_1) {
                Log.e("DrawableUtils", "Could not set mDrawableContainerStateField. Oh well.");
            }
        }

        return false;
    }

    public static boolean b(CharSequence arg2) {
        boolean v0 = arg2 == null || arg2.length() < 4 ? false : true;
        return v0;
    }

    //    @CheckReturnValue
    public static boolean equal(Object arg1, Object arg2) {
        boolean v0;
        if (arg1 != arg2) {
            if (arg1 != null && (arg1.equals(arg2))) {
                return true;
            }

            v0 = false;
        } else {
            label_4:
            v0 = true;
        }

        return v0;
    }

    public static boolean b(JSONObject arg2) throws JSONException {
        boolean v0 = "success".equals(arg2.optString("msg")) ? true : false;
        return v0;
    }

    @NonNull
    public static o c() {
        if (O == null) {
            O = new com.a.a.q((byte) 0);
        }

        return O;
    }

    public static void onEvent(String event, JSONObject jo) {
        long v4 = 0;
        if (!isTextEmpty(event)) {
            JSONObject v8 = jo == null ? new JSONObject() : jo;
            try {
                v8.put("_event_v3", 1);
            } catch (JSONException v0) {
                v0.printStackTrace();
            }
            AppLog.onEvent("event_v3", event, null, v4, v4, v8);
        }
    }

    public static void warnDeprecation(String arg3, String arg4) {
        Log.w("PullToRefresh", "You\'re using the deprecated " + arg3 + " attr, please switch over to " + arg4);
    }

    public static boolean isNetworkAvailable(Context context) {
        try {
            NetworkInfo networkInfo = ((ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
            if (networkInfo != null) {
                return networkInfo.isConnected();
            }
            return false;
        } catch (Exception e) {
            return false;
        }
    }

    private static String c(byte[] arg8) {
        String v0 = null;
        int v1 = 0;
        if (arg8 != null) {
            try {
                StringBuilder v2 = new StringBuilder();
                int v3 = arg8.length;
                while (v1 < v3) {
                    v2.append(String.format("%02x", Byte.valueOf(arg8[v1])));
                    ++v1;
                }

                v0 = v2.toString();
            } catch (Throwable v1_1) {
            }
        }

        return v0;
    }

    private static int dp2px(Context arg1, int arg2) {
        return arg1.getResources().getDimensionPixelSize(arg2);
    }

    public static String c(int arg7) {
        String v0;
        if (arg7 >= 10000) {
            v0 = String.format("%.1f", Double.valueOf(1 * (((double) arg7)) / 10000));
            v0 = 48 == v0.charAt(v0.length() - 1) ? v0.substring(0, v0.length() - 2) + "万" : v0 + "万";
        } else {
            v0 = String.valueOf(arg7);
        }

        return v0;
    }

    private static boolean c(Closeable arg1) {
        if (arg1 != null) {
            try {
                arg1.close();
                boolean v0_1 = true;
                return v0_1;
            } catch (IOException v0) {
            }
        }

        return false;
    }

    public static boolean isNullOrEmpty(List arg1) {
        return arg1 == null || (arg1.isEmpty());
    }

    private static String c(Cursor arg1, String arg2) {
        return arg1.getString(arg1.getColumnIndexOrThrow(arg2));
    }

    public static int c(View arg3) {
        if (!M) {
            try {
                Field v0_1 = View.class.getDeclaredField("mMinHeight");
                L = v0_1;
                v0_1.setAccessible(true);
            } catch (NoSuchFieldException v0) {
            }

            M = true;
        }

        if (L != null) {
            try {
                int v0_3 = ((Integer) L.get(arg3)).intValue();
                return v0_3;
            } catch (Exception v0_2) {
            }
        }

        return 0;
    }

    private static long c(File arg6) throws Exception {
        long v2 = 0;
        File[] v1 = arg6.listFiles();
        int v0;
        for (v0 = 0; v0 < v1.length; ++v0) {
            v2 += v1[v0].isDirectory() ? c(v1[v0]) : v1[v0].length();
        }

        return v2;
    }

    public static ToStringHelper toStringHelper(Object arg4) {
        String v2 = arg4.getClass().getName().replaceAll("\\$[0-9]+", "\\$");
        int v0 = v2.lastIndexOf(36);
        if (v0 == -1) {
            v0 = v2.lastIndexOf(46);
        }

        return new ToStringHelper(v2.substring(v0 + 1), (byte) 0);
    }

    public static com.ss.android.article.base.feature.b.a c(long arg8) {
        com.ss.android.article.base.feature.b.a v0_2;
        int v2_1;
        JSONArray v3;
        String v2;
        com.ss.android.article.base.feature.b.a v1 = null;
        Class v4 = a.class;
        synchronized (v4) {
            SharedPreferenceUtils.inst();
            v2 = SharedPreferenceUtils.getString(null, "app_ad_download", "");
            Logger.d("AppDownloadInfoManager", "getDownloadInfoByAdId, adId =  " + arg8 + ", downloadInfoJSonStr = " + v2);
            try {
                if (isTextEmpty(v2)) {
                    v3 = new JSONArray();
                } else {
                    v3 = new JSONArray(v2);
                }

                int v5 = v3.length();
                v2_1 = 0;
                while (true) {
                    label_26:
                    if (v2_1 >= v5) {
                        return v1;
                    }

                    v0_2 = com.ss.android.article.base.feature.b.a.a(v3.getJSONObject(v2_1));
                    if (v0_2 != null && v0_2.a == arg8) {
                        Logger.d("AppDownloadInfoManager", "getDownloadInfoByAdId success, adId =  " + arg8);
                        return v0_2;
                    }

                    ++v2_1;
                    continue;
                }
            } catch (Exception v0_1) {
                Logger.d("AppDownloadInfoManager", "getDownloadInfoByAdId, Exception, e.getCause() =  " + v0_1.getCause());
                v0_1.printStackTrace();
                return v1;
            }
        }
    }

    public static Object c(Context arg4, String arg5) {
        Object v0 = null;
        if (arg4 != null) {
            try {
                v0 = arg4.getPackageManager().getApplicationInfo(arg4.getPackageName(), PackageManager.GET_META_DATA).metaData.get(arg5);
            } catch (Exception v1) {
            }
        }

        return v0;
    }

    public static String c(String arg4, int arg5) {
        if ((isTextEmpty(arg4)) || arg5 <= 0) {
            arg4 = "";
        } else {
            int v1 = arg4.getBytes().length;
            if (v1 > arg5) {
                int v0 = arg4.length();
                while (v1 > arg5) {
                    v0 /= 2;
                    v1 = arg4.substring(0, v0).length();
                }

                v1 = v0 * 2;
                while (v0 < v1) {
                    if (arg4.substring(0, v0).getBytes().length > arg5) {
                        break;
                    }

                    ++v0;
                }

                arg4 = arg4.substring(0, v0 - 1);
            }
        }

        return arg4;
    }

    private static Field c(Object arg2, String arg3) {
        Field v0_1 = null;
        Class v0 = arg2.getClass();
        while (true) {
            if (v0 != Object.class) {
                try {
                    v0_1 = v0.getDeclaredField(arg3);
                    return v0_1;
                } catch (Exception v1) {
                    v0 = v0.getSuperclass();
                    continue;
                }
            } else {
                return null;
            }
        }
    }

    public static Field c(String arg4) {
        Field v0 = null;
        try {
            v0 = TextView.class.getDeclaredField(arg4);
            v0.setAccessible(true);
        } catch (NoSuchFieldException v1) {
            Log.e("TextViewCompatDonut", "Could not retrieve " + arg4 + " field.");
        }

        return v0;
    }

    public static void c(String arg8, String arg9, float arg10) {
        com.bytedance.frameworks.core.a.e.b v0_3 = null;
        HashMap v3;
        long v4;
        String v2;
        com.bytedance.frameworks.core.a.e v1;
        try {
            if (com.bytedance.framwork.core.monitor.c.j() == null) {
                com.bytedance.framwork.core.monitor.a.a().a(new com.bytedance.framwork.core.monitor.a.c(arg8, arg9, arg10, false, "timer"));
                return;
            }

            if (!o(arg8)) {
                return;
            }

            if (e() == null) {
                return;
            }

            if (!f()) {
                return;
            }

            com.bytedance.frameworks.core.a.b.b$a v0_1 = e();
            if (v0_1.a == null) {
                return;
            }

            if (TextUtils.isEmpty(((CharSequence) arg8))) {
                return;
            }

            if (TextUtils.isEmpty(((CharSequence) arg9))) {
                return;
            }

            v1 = v0_1.a;
            if (TextUtils.isEmpty(((CharSequence) arg8))) {
                return;
            }

            if (TextUtils.isEmpty(((CharSequence) arg9))) {
                return;
            }

            v2 = arg9 + arg8;
            v4 = System.currentTimeMillis() / 1000;
            v3 = v1.b;

            synchronized (v3) {
                Object v0_2 = v1.b.get(v2);
                if (v0_2 == null) {
                    v0_3 = new com.bytedance.frameworks.core.a.e.b(arg9, arg8, v4);
                    v1.b.put(v2, v0_3);
                }

                v0_3.d += arg10;
                ++v0_3.c;
                return;
            }
        } catch (Throwable v0) {
            v0.printStackTrace();
        }
    }

    public static long[] c(JSONArray arg6) {
        long[] v1 = null;
        if (arg6 != null && arg6.length() > 0) {
            try {
                int v3 = arg6.length();
                long[] v0_1 = new long[v3];
                int v2 = 0;
                while (true) {
                    if (v2 < v3) {
                        v0_1[v2] = arg6.getLong(v2);
                        ++v2;
                        continue;
                    } else {
                        return v0_1;
                    }
                }
            } catch (Exception v0) {
                return v1;
            }
        }

        return v1;
    }

    public static <T> T d(T arg1) {
        if (arg1 == null) {
            throw new NullPointerException();
        }

        return arg1;
    }

    private static Object d(Object arg2, String arg3) {
        Object v0_2;
        Field v0 = c(arg2, arg3);
        v0.setAccessible(true);
        try {
            v0_2 = v0.get(arg2);
        } catch (Exception v0_1) {
            v0_1.printStackTrace();
            v0_2 = null;
        }

        return v0_2;
    }

    private static Uri d(Cursor arg1, String arg2) {
        Uri v0_1;
        try {
            v0_1 = Uri.parse(c(arg1, arg2));
        } catch (NullPointerException v0) {
            v0_1 = null;
        }

        return v0_1;
    }

    private static List d(JSONArray arg6) {
        ArrayList v1 = new ArrayList();
        if (arg6 != null) {
            int v0;
            for (v0 = 0; v0 < arg6.length(); ++v0) {
                JSONObject v2 = arg6.optJSONObject(v0);
                if (v2 != null) {
                    EntryItem v3 = EntryItem.obtain(v2.optLong("id"));
                    v3.extractFields(v2);
                    ((List) v1).add(v3);
                }
            }
        }

        return v1;
    }

    public static int d(Context arg1, String arg2) {
        return ((Integer) c(arg1, arg2)).intValue();
    }

    public static int d(String arg1, int arg2) {
        if (arg1 != null) {
            try {
                if (arg1.length() == 0) {
                    return arg2;
                }

                arg2 = Integer.parseInt(arg1);
            } catch (Exception v0) {
            }
        }

        return arg2;
    }

    public static long d() {
        long v0_3;
        try {
            BufferedReader v0_1 = new BufferedReader(new InputStreamReader(new FileInputStream("/proc/stat")), 1000);
            String v1 = v0_1.readLine();
            v0_1.close();
            String[] v0_2 = v1.split(" ");
            v0_3 = Long.parseLong(v0_2[8]) + (Long.parseLong(v0_2[2])
                    + Long.parseLong(v0_2[3])
                    + Long.parseLong(v0_2[4])
                    + Long.parseLong(v0_2[6])
                    + Long.parseLong(v0_2[5])
                    + Long.parseLong(v0_2[7]));
        } catch (IOException v0) {
            v0.printStackTrace();
            v0_3 = -1;
        }

        return v0_3;
    }

    public static Bundle createJumpData(String extraTitleType, String extraSource) {
        Bundle bundle = new Bundle();
        bundle.putString("extra_title_type", extraTitleType);
        bundle.putString("extra_source", extraSource);
        return bundle;
    }

    public static EntryItem d(long arg6) {
        EntryItem v0 = null;
        if (arg6 > 0) {
            try {
                UrlBuilder v1_1 = new UrlBuilder(ArticleConstants.entryProfileUrlV1);
                v1_1.addParam("entry_id", arg6);
                String v1_2 = NetworkUtils.doGet(-1, v1_1.build());
                if (isTextEmpty(v1_2)) {
                    return v0;
                }

                JSONObject v2 = new JSONObject(v1_2);
                if (!AbsApiThread.isApiSuccess(v2)) {
                    Logger.d("SubscribeHelper", "get entry profile error: " + v2);
                    return v0;
                }

                v2 = v2.getJSONObject("data");
                if (v2.optLong("id") != arg6) {
                    return v0;
                }

                EntryItem v1_3 = EntryItem.obtain(arg6);
                v1_3.extractFields(v2);
                v0 = v1_3;
            } catch (Throwable v1) {
                Logger.w("SubscribeHelper", "get entry profile exception: " + v1);
            }
        }

        return v0;
    }

    public static com.ss.android.newmedia.b.a d(int arg1) {
        com.ss.android.newmedia.b.b v0_2 = null;
        switch (arg1) {
            case 1: {
                return new com.ss.android.newmedia.b.c();
            }
            case 2: {
                return new com.ss.android.newmedia.b.b();
            }
        }

        return v0_2;
    }

    public static String d(Context arg2) {
        try {
            if (Build.VERSION.SDK_INT >= 23) {
                String v0_1 = B();
                if (isTextEmpty(v0_1)) {
//                    goto label_7;
                } else {
                    return v0_1;
                }
            }

//            label_7:
            WifiInfo v0_2 = ((WifiManager) arg2.getSystemService(Context.WIFI_SERVICE)).getConnectionInfo();
            if (v0_2 == null) {
                return null;
            }

            return v0_2.getMacAddress();
        } catch (Throwable v0) {
        }

        return null;
    }

    public static boolean d(View arg3) {
        Rect v0 = new Rect();
        arg3.getWindowVisibleDisplayFrame(v0);
        boolean v0_1 = (((float) (arg3.getBottom() - v0.bottom))) > arg3.getResources().getDisplayMetrics().density * 100f ? true : false;
        return v0_1;
    }

    public static boolean d(String arg10) {
        int v9 = 1024;
        int v0 = 0;
        StackTraceElement[] v1 = Thread.currentThread().getStackTrace();
        if (v1 == null) {
            return true;
        }

        try {
            if (v1.length > 4) {
                StackTraceElement v2 = v1[3];
                if (v2 == null) {
                    return true;
                }

                String v3 = v2.getClassName();
                String v4 = v2.getMethodName();
                int v2_1 = v2.getLineNumber();
                if (v1 == null || v1.length <= 0) {
                    throw new IllegalArgumentException("stackTraceElements must not be null or empty");
                }

                StringBuilder v5 = new StringBuilder();
                while (v0 < v1.length) {
                    if (v0 > 40) {
                        break;
                    }

                    v5.append("\tat " + v1[v0].getClassName())
                            .append(".")
                            .append(v1[v0].getMethodName())
                            .append("(")
                            .append(v1[v0].getFileName())
                            .append(":")
                            .append(v1[v0].getLineNumber())
                            .append(")\n");
                    ++v0;
                }

                String v0_2 = v5.toString();
                JSONObject v1_1 = new JSONObject();
                v1_1.put("event_type", "exception");
                v1_1.put("timestamp", System.currentTimeMillis());
                v1_1.put("class_ref", v3);
                v1_1.put("method", v4);
                v1_1.put("line_num", v2_1);
                v1_1.put("stack", v0_2);
                v1_1.put("exception_type", 1);
                v1_1.put("is_core", 1);
                if (!TextUtils.isEmpty(((CharSequence) arg10))) {
                    if (arg10.length() > v9) {
                        v1_1.put("message", arg10.substring(0, 1024));
                    } else {
                        v1_1.put("message", arg10);
                    }
                }

                com.bytedance.article.common.a.d.c.a().a("core_exception_monitor", v1_1.toString(), arg10, true);
            }

            return true;
        } catch (Throwable v0_1) {
            v0_1.printStackTrace();
            return true;
        }
    }

    public static String e(String arg2, String arg3) {
        if (!isTextEmpty(arg2) && !isTextEmpty(arg3)) {
            try {
                if (!"forum".equals(Uri.parse(arg2).getHost())) {
                    return arg2;
                }

                UrlBuilder v0_1 = new UrlBuilder(arg2);
                if (!isTextEmpty(arg3)) {
                    v0_1.addParam("enter_from", arg3);
                }

                arg2 = v0_1.build();
            } catch (Exception v0) {
            }
        }

        return arg2;
    }

    public static NetworkType getNetworkType(Context arg2) {
        NetworkType v0_2 = null;
        try {
            NetworkInfo v0_1 = ((ConnectivityManager) arg2.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
            if (v0_1 == null || !v0_1.isAvailable()) {
                v0_2 = NetworkType.NONE;
                return v0_2;
            }

            int v0_3 = v0_1.getType();
            if (1 == v0_3) {
                return NetworkType.WIFI;
            }

            if (v0_3 != 0) {
                return NetworkType.MOBILE;
            }

            switch (((TelephonyManager) arg2.getSystemService(Context.TELEPHONY_SERVICE)).getNetworkType()) {
                case 13: {
                    return NetworkType.MOBILE_4G;
                }
                case 3:
                case 5:
                case 6:
                case 8:
                case 9:
                case 10:
                case 12:
                case 14:
                case 15: {
                    return NetworkType.MOBILE_3G;
                }
            }
        } catch (Throwable v0) {
            v0_2 = NetworkType.MOBILE;
        }

        return v0_2;
    }

    public static com.bytedance.frameworks.core.a.b.b$a e() {
        com.bytedance.frameworks.core.a.b.b$a v0 = com.bytedance.framwork.core.monitor.c.j() != null ? com.bytedance.framwork.core.monitor.c.j().b : null;
        return v0;
    }

    public static int e(int arg0) {
        return arg0;
    }

    public static int e(String arg4) {
        int v0 = 0;
        try {
            switch (new ExifInterface(arg4).getAttributeInt("Orientation", 1)) {
                case 3: {
                    return 180;
                }
                case 6: {
                    return 90;
                }
                case 8: {
                    return 270;
                }
            }
        } catch (IOException v1) {
            v1.printStackTrace();
        }

        return v0;
    }

    public static <T> T e(T arg3) {
        Class[] v0_1;
        if (arg3 == null) {
            return null;
        }

        try {
            Class<?> v1 = arg3.getClass();
            if (v1 == null) {
                v0_1 = new Class[0];
            } else {
                HashSet v0_2 = new HashSet();
                a(v1, ((Set<Class<?>>) v0_2));
                v0_1 = (Class[]) ((Set) v0_2).toArray(new Class[0]);
            }

            if (v0_1 == null) {
                return arg3;
            }

            if (v0_1.length <= 0) {
                return arg3;
            }
            arg3 = (T) Proxy.newProxyInstance(
                    v1.getClassLoader(), v0_1,
                    new com.ss.android.article.base.utils.m(arg3));
        } catch (Throwable v0) {
        }

        return arg3;
    }

    public static boolean e(Context arg5, String arg6) {
        boolean v0_4;
        if (arg5 != null && !TextUtils.isEmpty(((CharSequence) arg6))) {
            try {
                Object v0_1 = arg5.getSystemService(Context.ACTIVITY_SERVICE);
                if (Build.VERSION.SDK_INT < 21) {
                    List<ActivityManager.RunningTaskInfo> v0_2 = ((ActivityManager) v0_1).getRunningTasks(1);
                    if (!v0_2.isEmpty()) {
                        ComponentName v0_3 = v0_2.get(0).topActivity;
                        if (v0_3 == null) {
                            return false;
                        } else if (arg6.equals(v0_3.getPackageName())) {
                            v0_4 = true;
                            return v0_4;
                        } else {
                            return false;
                        }
                    } else {
                        return false;
                    }
                } else {
                    Iterator v1 = ((ActivityManager) v0_1).getRunningAppProcesses().iterator();
                    do {
                        if (v1.hasNext()) {
                            v0_1 = v1.next();
                            if (((ActivityManager.RunningAppProcessInfo) v0_1).importance != 100) {
                                continue;
                            }

                            break;
                        } else {
                            return false;
                        }
                    }
                    while (true);

                    return arg6.equals(((ActivityManager.RunningAppProcessInfo) v0_1).pkgList[0]);
                }
            } catch (Throwable v0) {
            }

            label_39:
            v0_4 = false;
        } else {
            label_5:
            v0_4 = false;
        }

        return v0_4;
    }

    public static boolean reuseItem(View view) {
        return view != null && view.getTag(com.ss.android.article.browser.R.id.item_reuse_tag) == Boolean.TRUE;
    }

    private static int[] e(JSONArray arg5) {
        int[] v1_1;
        int[] v0 = null;
        if (arg5.length() > 0) {
            try {
                int v3 = arg5.length();
                v1_1 = new int[v3];
                int v2;
                for (v2 = 0; v2 < v3; ++v2) {
                    v1_1[v2] = arg5.getInt(v2);
                }
            } catch (Exception v1) {
                return v0;
            }

            v0 = v1_1;
        }

        return v0;
    }

    public static boolean isTextEmpty(String text) {
        return text == null || text.length() == 0;
    }

    public static boolean f() {
        boolean v0;
        if (com.bytedance.framwork.core.monitor.c.j() != null) {
            com.bytedance.framwork.core.monitor.c.j();
            v0 = com.bytedance.framwork.core.monitor.c.k();
        } else {
            v0 = false;
        }

        return v0;
    }

    public static int f(int arg4) {
        int v0 = arg4 << 3;
        int v1 = 4;
        while (v1 < 32) {
            if (v0 <= (1 << v1) - 12) {
                v0 = (1 << v1) - 12;
            } else {
                ++v1;
                continue;
            }

            break;
        }

        return v0 / 8;
    }

    public static long f(Context arg4) {
        long v0 = -1;
        if (arg4 != null) {
            long v2 = arg4 == null ? v0 : TrafficStats.getUidRxBytes(Process.myUid());
            if (arg4 != null) {
                v0 = TrafficStats.getUidTxBytes(Process.myUid());
            }

            v0 += v2;
        }

        return v0;
    }

    public static String f(Context arg3, String arg4) {
        String v0 = null;
        if (arg3 != null && AccountManager.get(arg3) != null) {
            Account[] v1 = AccountManager.get(arg3).getAccountsByType(arg4);
            if (v1 != null && v1.length > 0) {
                v0 = v1[0].name;
            }
        }

        return v0;
    }

    public static String f(String arg2, String arg3) {
        if (!isTextEmpty(arg2)) {
            String v0 = JsonUtil.a(arg2, "enter_from");
            if (!isTextEmpty(v0)) {
                arg2 = JsonUtil.a(arg2, "parent_enterfrom", v0);
            }

            if (isTextEmpty(arg3)) {
                return arg2;
            }

            arg2 = JsonUtil.a(arg2, "enter_from", arg3);
        }

        return arg2;
    }

    private static Object g(Object arg2) {
        return b(d(arg2, "mMainThread"), "getApplicationThread");
    }

    private static Signature[] g(Context arg5, String arg6) {
        Signature[] v0_1;
        Signature[] v1 = null;
        try {
            v0_1 = arg5.getPackageManager().getPackageArchiveInfo(arg6, PackageManager.GET_SIGNATURES).signatures;
        } catch (Exception v0) {
            Logger.w("SignUtils", "failed to get package signatures: " + v0);
            v0_1 = v1;
        }

        if (v0_1 == null) {
            v0_1 = K(arg6);
        }

        return v0_1;
    }

    public static float g(Context arg7) {
        long v0_3;
        long v4;
        float v2 = -1f;
        if (arg7 == null) {
            float v0 = v2;
            return v0;
        }

        try {
            String v0_2 = arg7.getPackageName();
            if (TextUtils.isEmpty(((CharSequence) v0_2))) {
                return v2;
            }

            File v3 = new File("/data/data/" + v0_2);
            if (!v3.exists()) {
                return v2;
            }

            v4 = c(v3);
            v3 = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/Android/data/" + v0_2);
            v0_3 = 0;
            if (v3.exists()) {
                v0_3 = c(v3);
            }
        } catch (Throwable v0_1) {
            v0_1.printStackTrace();
            return v2;
        }

        return ((float) ((((double) (v0_3 + v4))) / 1048576));
    }

    public static String g(String arg4) {
        if (!isTextEmpty(arg4)) {
            try {
                arg4 = arg4.replace("[ss_random]", String.valueOf(new Random().nextLong())).replace("[ss_timestamp]", String.valueOf(System.currentTimeMillis()));
            } catch (Exception v0) {
                v0.printStackTrace();
            }
        }

        return arg4;
    }

    public static List g() {
        ArrayList v1 = new ArrayList();
        JSONArray v2 = ((com.ss.android.account.v2.bb) ComponentsManifest.findComponent(com.ss.android.account.v2.bb.class)).b().d();
        if (v2 != null) {
            int v0;
            for (v0 = 0; v0 < v2.length(); ++v0) {
                if (!v2.isNull(v0)) {
                    String v3 = v2.optString(v0);
                    if (!TextUtils.isEmpty(((CharSequence) v3))) {
                        ((List) v1).add(v3);
                    }
                }
            }
        }

        return ((List) v1);
    }

    public static void log2File(String path, String info) {
        FileWriter fileWriter = null;
        File file = new File(path);
        if (file.exists()) {
            return;
        }

        try {
            fileWriter = new FileWriter(file);
            fileWriter.write("STOP recv stop info:" + info + ".time:" + w() + "\r\n");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        } finally {
            try {
                fileWriter.close();
            } catch (IOException exception) {
                exception.printStackTrace();
            }
        }
    }

    public static boolean h() {
        boolean v0 = true;
        if (AppData.getInstance().mShowLiteSubEntranceList != 1) {
            v0 = false;
        }

        return v0;
    }

    private static String h(String arg2, String arg3) {
        if (arg3 == null) {
            arg3 = "ISO-8859-1";

        }
        try {
            return URLEncoder.encode(arg2, arg3);
        } catch (UnsupportedEncodingException v0) {
            throw new IllegalArgumentException(((Throwable) v0));
        }
    }

    public static float h(Context arg8) {
        long v4;
        String v3;
        long v0 = 0;
        float v2 = -1f;
        if (arg8 == null) {
            float v0_1 = v2;
            return v0_1;
        }

        try {
            v3 = arg8.getPackageName();
            if (TextUtils.isEmpty(((CharSequence) v3))) {
                return v2;
            }

            File v5 = new File("/data/data/" + v3 + "/cache");
            if (v5.exists()) {
                v4 = c(v5);
            } else {
                v4 = v0;
            }

//            label_22:
            File v6 = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/Android/data/" + v3 + "/cache");
            if (v6.exists()) {
                v0 = c(v6);
            }
        } catch (Throwable v0_2) {
            label_45:
            v0_2.printStackTrace();
            return v2;
        }

        return ((float) ((((double) (v0 + v4))) / 1048576));
    }

    public static String h(String arg3) {
        try {
            if (TextUtils.isEmpty(((CharSequence) arg3))) {
                return null;
            }

            byte[] v1 = arg3.getBytes("UTF-8");
            int v0_1;
            for (v0_1 = 0; v0_1 < v1.length; ++v0_1) {
                v1[v0_1] = ((byte) (v1[v0_1] ^ 5));
            }

            return com.bytedance.common.utility.aa.a(v1, v1.length);
        } catch (Exception v0) {
            return arg3;
        }
    }

    public static boolean i() {
        if (!R) {
            boolean v0 = AppData.getInstance().detailSearchTabStyle == 2 ? true : false;
            S = v0;
            R = true;
        }

        return S;
    }

    private static boolean i(String arg7, String arg8) {
        int v2_1;
        FileOutputStream v1_2 = null;
        FileInputStream v3 = null;
        FileInputStream v2 = null;
        boolean v0 = false;
        File v4 = new File(arg8);
        if (!v4.exists()) {
            return v0;
        }

        if (!v4.isFile()) {
            return v0;
        }

        File v5 = new File(arg7);
        if (v5.exists()) {
            new File(arg7).delete();
        } else if (!v5.getParentFile().exists() && !v5.getParentFile().mkdirs()) {
            return v0;
        }

        try {
            v3 = new FileInputStream(v4);
            v1_2 = new FileOutputStream(v5);
            v2_1 = 1024;
            byte[] v2_4 = new byte[v2_1];
            while (true) {
                int v5_1 = ((InputStream) v3).read(v2_4);
                if (v5_1 == -1) {
                    break;
                }
                ((OutputStream) v1_2).write(v2_4, 0, v5_1);
            }
            v4.delete();
        } catch (Throwable v0_1) {
        } finally {
            try {
                v3.close();
            } catch (Exception e) {

            }

            try {
                v1_2.close();
            } catch (Exception e) {

            }
        }
        return v0;
    }

    public static String i(Context arg3) throws NullPointerException {
        String v0_1 = null;
        CharSequence v0 = null;
        if (arg3 == null) {
            throw new NullPointerException("Context is NUll");
        }

        try {
            if (arg3.getCacheDir() != null) {
                v0_1 = arg3.getCacheDir().getPath();
//                goto label_10;
            } else {
                File v1_1 = arg3.getDir("/data/data/" + arg3.getPackageName() + "/cache/", 0);
                if (v1_1 == null) {
//                goto label_10;
                } else {
                    v0_1 = v1_1.getPath();
                }
            }
        } catch (Throwable v1) {
        }

        label_10:
        if (TextUtils.isEmpty(((CharSequence) v0_1))) {
            throw new NullPointerException("Cannot Create Cache Dir");
        }

        return v0_1;
    }

    public static String i(String arg5) {
        int v0 = 0;
        try {
            if (TextUtils.isEmpty(((CharSequence) arg5))) {
                return null;
            }

            byte[] v1 = com.bytedance.common.utility.aa.a(arg5);
            while (v0 < v1.length) {
                v1[v0] = ((byte) (v1[v0] ^ 5));
                ++v0;
            }

            return new String(v1, 0, v1.length, "UTF-8");
        } catch (Exception v0_1) {
            return arg5;
        }
    }

    public static LastReadDataManager j() {
        AppData.getInstance();
        AbsApplication cVar = AbsApplication.getApplication();
        SharedPreferences sp = AppData.getAppSettingSp(cVar);
        return LastReadDataManager.a(sp);
    }

    public static String j(String arg1) {
        if (arg1 != null && arg1.length() != 0) {
            arg1 = arg1.trim();
        }

        return arg1;
    }

    public static void j(Context arg9) {
        if (arg9 != null) {
            try {
                String v1 = arg9.getPackageName();
                String v2 = arg9.getString(arg9.getApplicationInfo().labelRes);
                if (TextUtils.isEmpty(((CharSequence) v2))) {
                    return;
                }

                if (TextUtils.isEmpty(((CharSequence) v1))) {
                    return;
                }

                Account v0_1 = new Account(v2, v1);
                AccountManager v3 = AccountManager.get(arg9);
                if (v3.addAccountExplicitly(v0_1, null, null)) {
                    ContentResolver.setIsSyncable(v0_1, "com.ss.android.account.AccountProvider1212", 1);
                    ContentResolver.setSyncAutomatically(v0_1, "com.ss.android.account.AccountProvider1212", true);
                    ContentResolver.addPeriodicSync(v0_1, "com.ss.android.account.AccountProvider1212", new Bundle(), 900);
                }

                Account[] v3_1 = v3.getAccounts();
                if (v3_1 == null) {
                    return;
                }

                int v4 = v3_1.length;
                int v0_2;
                for (v0_2 = 0; v0_2 < v4; ++v0_2) {
                    Account v5 = v3_1[v0_2];
                    if (v5 != null && !v2.equals(v5.name) && (v1.equals(v5.type)) && v5 != null) {
                        AccountManager v6 = AccountManager.get(arg9);
                        if (Build.VERSION.SDK_INT >= 22) {
                            v6.removeAccountExplicitly(v5);
                        } else {
                            v6.removeAccount(v5, null, null);
                        }
                    }
                }
            } catch (Throwable v0) {
                v0.printStackTrace();
            }
        }
    }

    public static BrowserISApi createBrowserISApi() {
        return (BrowserISApi) RetrofitWrapper.getISRetrofit().create(BrowserISApi.class);
    }

    public static boolean hasSSMix(String contentType) {
        if (contentType != null) {
            int index = contentType.indexOf("application/octet-stream");
            if (index >= 0) {
                index = contentType.indexOf("ssmix=", index + 24);
            }
            return index > 0;
        }
        return false;
    }

    public static String k(Context arg2) {
        String v0_1;
        try {
            v0_1 = com.bytedance.common.utility.a.b.b(((TelephonyManager) arg2.getSystemService(Context.TELEPHONY_SERVICE)));
            if (!TextUtils.isEmpty(((CharSequence) v0_1))) {
                return v0_1;
            }

            v0_1 = ((com.ss.android.account.v2.bb) ComponentsManifest.findComponent(com.ss.android.account.v2.bb.class)).b().c();
        } catch (Exception v0) {
            v0_1 = "";
        }

        return v0_1;
    }

    public static List<NavigationBean> getWebsiteNavigationBeanList() {
        mWebsiteNavigationBeanList = new ArrayList(5);
        Iterator<WebsiteNaviItem> iterator = Constants.sWebsiteNaviItemList.iterator();
        while (iterator.hasNext()) {
            WebsiteNaviItem websiteNaviItem = iterator.next();
            NavigationBean navigationBean = new NavigationBean();
            navigationBean.icon_url = websiteNaviItem.mIconResId + "";
            navigationBean.open_url = websiteNaviItem.mOpenUrl;
            navigationBean.screen_name = websiteNaviItem.mLabelResId + "";
            mWebsiteNavigationBeanList.add(navigationBean);
        }
        return mWebsiteNavigationBeanList;
    }

    public static boolean l(Context context) {
        try {
            if (((TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE)).getSimState() != 5) {
                return false;
            }
        } catch (Exception v0) {
            boolean v0_1 = false;
            return v0_1;
        }

        return true;
    }

    public static boolean l(String arg1) {
        boolean v0;
        if (arg1 == null || h == null) {
            v0 = false;
        } else if (h.a()) {
            v0 = true;
        } else {
            v0 = h.a(arg1);
        }

        return v0;
    }

    public static boolean m(String arg1) {
        boolean v0 = (TextUtils.isEmpty(((CharSequence) arg1))) || com.bytedance.framwork.core.monitor.c.j() == null ? false : com.bytedance.framwork.core.monitor.c.j().b(arg1);
        return v0;
    }

    public static int m() {
        if (!t) {
            U = 2;
            t = true;
        }
        return U;
    }

    public static void m(Context arg3) {
        try {
            ((InputMethodManager) arg3.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(((Activity) arg3).getWindow().getDecorView().getWindowToken(), 0);
        } catch (Exception v0) {
        }
    }

    public static boolean n() {
        long currentTimeMillis = System.currentTimeMillis();
        boolean v0 = currentTimeMillis - V < 1000;
        V = currentTimeMillis;
        return v0;
    }

    public static boolean isTest(Context context) {
        return Logger.debug()
                || ("local_test".equals(TtProperties.getInstance(context).readKey("meta_umeng_channel")));
    }

    public static boolean n(String arg3) {
        boolean v0 = false;
        if (!TextUtils.isEmpty(arg3) && com.bytedance.framwork.core.monitor.c.j() != null) {
            com.bytedance.framwork.core.monitor.c v1 = com.bytedance.framwork.core.monitor.c.j();
            if (v1.e != null && !TextUtils.isEmpty(((CharSequence) arg3)) && v1.e.opt(arg3) != null) {
                v0 = true;
            }
        }

        return v0;
    }

    public static boolean o(String arg1) {
        boolean v0 = (TextUtils.isEmpty(((CharSequence) arg1))) || com.bytedance.framwork.core.monitor.c.j() == null ? false : com.bytedance.framwork.core.monitor.c.j().c(arg1);
        return v0;
    }

    public static h o() {
        if (u == null) {
            throw new IllegalArgumentException("DownloadConfig is null !!!");
        }

        return u;
    }

    public static boolean o(Context context) {
        return context != null && UIUtils.getScreenWidth(context) > 1080;
    }

    public static DefaultSettingHandler$Status p(Context context) {
        DefaultSettingHandler$Status v0_1;
        ArrayList v0 = getPreferredBrowser(context);
        s = v0;
        if (((List) v0).isEmpty()) {
            v0_1 = DefaultSettingHandler$Status.NONE;
        } else if (a(s, context)) {
            v0_1 = DefaultSettingHandler$Status.OK;
        } else {
            v0_1 = DefaultSettingHandler$Status.OTHER;
        }

        return v0_1;
    }

    public static String decode(String input) throws Throwable {
        PublicKey publicKey = KeyFactory.getInstance("RSA")
                .generatePublic(new X509EncodedKeySpec(
                        Base64.decode("MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDQwuhlG2hSvAH1pxaCawFQTHQPEa+MLm0muwhkPd6hCTxmodQOCTbwWzaZazk8GDtV4AwBAM8jIeHP7z9bYxmZeT/lKjgvbplEWURevOQ4O6rYahjL8i4vyf431ocW+POx+kQbJ8Tr4EAuqjEUmP2nw6WUQ6/hMjQv/CS6SfqpEQIDAQAB", 0)));
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(2, publicKey);
        return new String(cipher.doFinal(Base64.decode(input, 0)));
    }

    public static boolean p() {
        return u == null || (u.a());
    }

    public static boolean q(String arg2) {
        boolean v0 = arg2 == null || arg2.length() != 8 || !TextUtils.isDigitsOnly(arg2) ? false : true;
        return v0;
    }

    public static ArrayList<ResolveInfo> getPreferredBrowser(Context context) {
        ArrayList<ResolveInfo> result = new ArrayList();
        PackageManager packageManager = context.getPackageManager();
        Intent intent = new Intent("android.intent.action.VIEW");
        intent.addCategory("android.intent.category.BROWSABLE");
        intent.setData(Uri.parse("http://www.baidu.cn"));
        try {
            List<ResolveInfo> resolveInfoList = packageManager.queryIntentActivities(intent, 0);
            if (resolveInfoList == null) {
                return result;
            }
            ArrayList<ComponentName> componentNameList = new ArrayList();
            ArrayList<IntentFilter> intentFilterList = new ArrayList();
            Iterator<ResolveInfo> resolveInfoIterator = resolveInfoList.iterator();
            while (true) {
                if (!resolveInfoIterator.hasNext()) {
                    return result;
                }

                ResolveInfo resolveInfo = resolveInfoIterator.next();
                packageManager.getPreferredActivities(intentFilterList, componentNameList, resolveInfo.activityInfo.packageName);
                Iterator<IntentFilter> intentFilterIterator = intentFilterList.iterator();
                while (true) {
                    if (!intentFilterIterator.hasNext()) {
                        break;
                    }

                    IntentFilter filter = intentFilterIterator.next();
                    if (!filter.hasCategory("android.intent.category.BROWSABLE")
                            && !filter.hasCategory("android.intent.category.DEFAULT")) {
                        continue;
                    }
                    if (!filter.hasDataScheme("http")) {
                        continue;
                    }
                    result.add(resolveInfo);
                }
            }
        } catch (Exception exception) {
            d("默认浏览器信息 获取失败");
        }
        return result;
    }

    public static String q() {
        if (isTextEmpty(w)) {
            throw new IllegalArgumentException("Download spName is null !!!");
        }

        return w;
    }

    public static ArticleDetail getDetailCache(String key) {
        Object v0;
        ArticleDetail v1 = null;
        if ((isTextEmpty(key)) || Q == null) {
            if (Logger.debug()) {
                Logger.d("ArticleDetailCache", "getDetailCache, key = " + key + ", detail = null");
            }
            v0 = v1;
        } else {
            v0 = Q.get();
            if (v0 == null) {
                if (Logger.debug()) {
                    Logger.d("ArticleDetailCache", "getDetailCache, key = " + key + ", detail = null");
                }
                v0 = v1;
            } else {
                v0 = ((Map) v0).get(key);
                if (!Logger.debug()) {
                    return ((ArticleDetail) v0);
                }
                Logger.d("ArticleDetailCache", "getDetailCache, key = " + key + ", detail = " + v0);
            }
        }
        return ((ArticleDetail) v0);
    }

    public static boolean r() {
        boolean v1;
        if (W != null) {
            v1 = W.booleanValue();
            return v1;
        }

        try {
            Method v1_2 = Build.class.getDeclaredMethod("getString", String.class);
            v1_2.setAccessible(true);
            String v2 = (String) v1_2.invoke(null, "ro.build.version.emui");
            if (((v2 instanceof String)) && !android.support.design.a.isTextEmpty(v2)) {
                if ("unknown".equals(v2)) {
                    v1 = false;
                    W = Boolean.valueOf(v1);
                    return v1;
                }

                v1 = true;
                W = Boolean.valueOf(v1);
                return v1;
            }

            v1 = false;
            W = Boolean.valueOf(v1);
            return v1;
        } catch (Throwable v1_1) {
            v1_1.printStackTrace();
            v1 = false;
            W = Boolean.valueOf(v1);
            return v1;
        }
    }

    public static boolean isComponentViewValid(Context context) {
        return context instanceof IComponent && ((IComponent) context).isViewValid();
    }

    public static boolean isComponentActive(Context context) {
        return context instanceof IComponent && ((IComponent) context).isActive();
    }

    public static boolean isTest() {
        return Logger.debug() || isDevOrTestChannel();
    }

    public static Intent s(String arg7) {
        Intent v0_1;
        int v6 = Intent.FLAG_ACTIVITY_CLEAR_TOP;
        int v4 = Intent.FLAG_ACTIVITY_NEW_TASK;
        File v0 = new File(arg7);
        if (!v0.exists()) {
            v0_1 = null;
        } else {
            String v0_2 = v0.getName().substring(v0.getName().lastIndexOf(".") + 1).toLowerCase();
            if (!v0_2.equals("m4a") && !v0_2.equals("mp3") && !v0_2.equals("mid") && !v0_2.equals("xmf") && !v0_2.equals("ogg") && !v0_2.equals("wav")) {
                if (!v0_2.equals("3gp") && !v0_2.equals("mp4") && !v0_2.equals("flv") && !v0_2.equals("mpg") && !v0_2.equals("rm")) {
                    if (!v0_2.equals("jpg") && !v0_2.equals("gif") && !v0_2.equals("png") && !v0_2.equals("jpeg") && !v0_2.equals("bmp")) {
                        if (v0_2.equals("apk")) {
                            v0_1 = new Intent("android.intent.action.VIEW");
                            v0_1.addFlags(v4);
                            v0_1.setAction("android.intent.action.VIEW");
                            v0_1.setDataAndType(Uri.parse("file://" + arg7), "application/vnd.android.package-archive");
                        } else if (v0_2.equals("ppt")) {
                            v0_1 = new Intent("android.intent.action.VIEW");
                            v0_1.addCategory("android.intent.category.DEFAULT");
                            v0_1.addFlags(v4);
                            v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "application/vnd.ms-powerpoint");
                        } else if (v0_2.equals("xls")) {
                            v0_1 = new Intent("android.intent.action.VIEW");
                            v0_1.addCategory("android.intent.category.DEFAULT");
                            v0_1.addFlags(v4);
                            v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "application/vnd.ms-excel");
                        } else if (v0_2.equals("doc")) {
                            v0_1 = new Intent("android.intent.action.VIEW");
                            v0_1.addCategory("android.intent.category.DEFAULT");
                            v0_1.addFlags(v4);
                            v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "application/msword");
                        } else if (v0_2.equals("pdf")) {
                            v0_1 = new Intent("android.intent.action.VIEW");
                            v0_1.addCategory("android.intent.category.DEFAULT");
                            v0_1.addFlags(v4);
                            v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "application/pdf");
                        } else if (v0_2.equals("chm")) {
                            v0_1 = new Intent("android.intent.action.VIEW");
                            v0_1.addCategory("android.intent.category.DEFAULT");
                            v0_1.addFlags(v4);
                            v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "application/x-chm");
                        } else if (v0_2.equals("txt")) {
                            v0_1 = new Intent("android.intent.action.VIEW");
                            v0_1.addCategory("android.intent.category.DEFAULT");
                            v0_1.addFlags(v4);
                            v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "text/plain");
                        } else {
                            v0_1 = new Intent();
                            v0_1.addFlags(v4);
                            v0_1.setAction("android.intent.action.VIEW");
                            v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "*/*");
                        }

                        return v0_1;
                    }

                    v0_1 = new Intent("android.intent.action.VIEW");
                    v0_1.addCategory("android.intent.category.DEFAULT");
                    v0_1.addFlags(v4);
                    v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "image/*");
                    return v0_1;
                }

                v0_1 = new Intent("android.intent.action.VIEW");
                v0_1.addFlags(v6);
                v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "video/*");
                return v0_1;
            }

            v0_1 = new Intent("android.intent.action.VIEW");
            v0_1.addFlags(v6);
            v0_1.putExtra("oneshot", 0);
            v0_1.putExtra("configchange", 0);
            v0_1.setDataAndType(Uri.fromFile(new File(arg7)), "audio/*");
        }

        return v0_1;
    }

    @Nullable
    public static Uri t(String arg3) {
        Uri v0 = null;
        if (!TextUtils.isEmpty(((CharSequence) arg3))) {
            Uri v1 = Uri.parse(arg3);
            if (!TextUtils.isEmpty(v1.getScheme()) && !TextUtils.isEmpty(v1.getHost())) {
                v0 = v1;
            }
        }

        return v0;
    }

    @NonNull
    public static List t() {
        ArrayList v2 = new ArrayList();
        JSONArray v3 = com.ss.android.lockscreen.aa.b();
        int v1;
        for (v1 = 0; v1 < v3.length(); ++v1) {
            try {
                ((List) v2).add(((JSONObject) v3.get(v1)).getString("package"));
            } catch (Exception v0) {
            }
        }

        return ((List) v2);
    }

    public static boolean t(Context arg1) {
        boolean v0 = (arg1 instanceof IComponent) ? ((IComponent) arg1).isDestroyed() : true;
        return v0;
    }

    public static boolean u() {
        boolean v0 = true;
        int v1 = AppData.getInstance().getAbSettings().getVideoFixONLineQuestionFlage();
        if (v1 != 1 && (v1 & 8) <= 0) {
            v0 = false;
        }

        return v0;
    }

    public static boolean u(Context arg1) {
        boolean v0 = u == null || (u.b(arg1)) ? true : false;
        return v0;
    }

    public static boolean u(String arg2) {
        boolean v0 = false;
        if (!TextUtils.isEmpty(arg2) && ((arg2.startsWith("http:")) || (arg2.startsWith("ftp:")) || (arg2.startsWith("https:")))) {
            v0 = true;
        }
        return v0;
    }

    public static com.ss.android.common.download.e v(Context arg1) {
        com.ss.android.common.download.e v0 = u != null ? u.c(arg1) : null;
        return v0;
    }

    public static String v(String arg6) {
        String v0_1;
        Class v1 = a.class;
        synchronized (v1) {
            if (x == null) {
//                goto label_7;
            } else {
                v0_1 = x;
                return v0_1;
            }
        }

//        label_7:
        v0_1 = null;
        try {
            String v2_1 = L(arg6);
            if (isTextEmpty(v2_1)) {
//                goto label_34;
            } else {
                if (Logger.debug()) {
                    Logger.d("SemUtils", "appTrack = " + v2_1);
                }
                JSONObject v3 = new JSONObject(v2_1);
                v0_1 = v3.optString("openurl");
                if (Logger.debug()) {
                    Logger.d("SemUtils", "openurl = " + v0_1);
                }
                AppLog.a(v3);
//                goto label_34;
            }

            if (v0_1 != null) {
                if ((v0_1.startsWith("growth")) || (v0_1.startsWith("snssdk35"))) {
                    Uri v0_2 = Uri.parse(v0_1);
                    if ("growth".equals(v0_2.getScheme())) {
                        x = v0_2.getQuery();
//                            goto label_48;
                    } else {
                        if ("snssdk35".equals(v0_2.getScheme())) {
                            x = v0_2.getQuery();
                        }
                    }
                }
            }
            //                    label_48:
            if (x == null) {
                x = "";
            }

            v0_1 = x;
            return v0_1;
        } catch (Throwable v0) {
            v0.printStackTrace();
        }

        return v0_1;
    }

    public static boolean fixOnLineQuestion() {
        int videoFixONLineQuestionFlage = AppData.getInstance().getAbSettings().getVideoFixONLineQuestionFlage();
        return videoFixONLineQuestionFlage == 1 || (videoFixONLineQuestionFlage & 32) > 0;
    }

    public static int[] w(String arg2) {
        int[] v0 = null;
        if (!isTextEmpty(arg2)) {
            try {
                v0 = e(new JSONArray(arg2));
            } catch (Exception v1) {
            }
        }

        return v0;
    }

    public static String w() {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm ss:SSS").format(new Date());
    }

    public static String w(Context arg4) {
        String v0_2;
        Object v0_1;
        List v0 = ((ActivityManager) arg4.getSystemService(Context.ACTIVITY_SERVICE)).getProcessesInErrorState();
        if (v0 != null) {
            Iterator v1 = v0.iterator();
            do {
                if (v1.hasNext()) {
                    v0_1 = v1.next();
                    if (((ActivityManager.ProcessErrorStateInfo) v0_1).condition != 2) {
                        continue;
                    }

                    break;
                } else {
                    return null;
                }
            }
            while (true);

            v0_2 = "|------------- processErrorStateInfo--------------|\n"
                    + ("condition: " + ((ActivityManager.ProcessErrorStateInfo) v0_1).condition + "\n")
                    + ("processName: " + ((ActivityManager.ProcessErrorStateInfo) v0_1).processName + "\n")
                    + ("pid: " + ((ActivityManager.ProcessErrorStateInfo) v0_1).pid + "\n")
                    + ("uid: " + ((ActivityManager.ProcessErrorStateInfo) v0_1).uid + "\n")
                    + ("tag: " + ((ActivityManager.ProcessErrorStateInfo) v0_1).tag + "\n")
                    + ("shortMsg : " + ((ActivityManager.ProcessErrorStateInfo) v0_1).shortMsg + "\n")
                    + "-----------------------end----------------------------";
        } else {
            label_73:
            v0_2 = null;
        }

        return v0_2;
    }

    public static long x(String arg3) {
        long v0 = 0;
        if (arg3 != null) {
            try {
                if (arg3.length() == 0) {
                    return v0;
                }

                v0 = Long.parseLong(arg3);
            } catch (Exception v2) {
            }
        }

        return v0;
    }

    @NotNull
    public static Void x() {
        throw new UnsupportedOperationException("Not supported for local property reference.");
    }

    public static boolean x(Context arg6) {
        boolean v0_1;
        if (Build.VERSION.SDK_INT >= 16) {
            Object v0 = arg6.getSystemService(Context.KEYGUARD_SERVICE);
            if (v0 != null) {
                v0_1 = ((KeyguardManager) v0).isKeyguardSecure();
                return v0_1;
            }
        }

        String v0_2 = "com.android.internal.widget.LockPatternUtils";
        try {
            Class v0_4 = Class.forName(v0_2);
            v0_1 = ((Boolean) v0_4.getMethod("isSecure").invoke(v0_4.getConstructor(Context.class).newInstance(arg6.getApplicationContext()))).booleanValue();
        } catch (Exception v0_3) {
            v0_1 = false;
        }

        return v0_1;
    }

    public static String y() {
        String v0 = com.bytedance.ttnet.cc.a().f();
        if (TextUtils.isEmpty(v0)) {
            v0 = "ib";
        }

        return v0;
    }

    public static String y(String arg3) throws FileNotFoundException, IOException {
        String v0;
        if (TextUtils.isEmpty(((CharSequence) arg3))) {
            v0 = null;
        } else {
            BufferedReader v1 = new BufferedReader(new FileReader(new File(arg3)));
            StringBuilder v0_1 = new StringBuilder();
            while (true) {
                String v2 = v1.readLine();
                if (v2 == null) {
                    break;
                }

                v0_1.append(v2);
            }

            CrashUtils.a(((Closeable) v1));
            v0 = v0_1.toString();
        }

        return v0;
    }

    public static boolean y(Context arg4) {
        boolean v0_2;
        try {
            Object v0_1 = arg4.getSystemService(Context.POWER_SERVICE);
            if (Build.VERSION.SDK_INT >= 20) {
                v0_2 = ((PowerManager) v0_1).isInteractive();
                return v0_2;
            }

            v0_2 = ((PowerManager) v0_1).isScreenOn();
        } catch (Exception v0) {
            v0_2 = true;
        }

        return v0_2;
    }

    public static int z(Context arg11) {
        int v1 = -1;
        if (arg11 == null) {
            int v0 = v1;
            return v0;
        }

        try {
            Object v0_2 = arg11.getSystemService(Context.APP_OPS_SERVICE);
            ApplicationInfo v4 = arg11.getApplicationInfo();
            String v5 = arg11.getApplicationContext().getPackageName();
            int v4_1 = v4.uid;
            Reflect v6 = Reflect.on(v0_2);
            if (((Integer) v6.call("checkOpNoThrow",
                    new Class[]{Integer.TYPE, Integer.TYPE, String.class},
                    new Object[]{Integer.valueOf(((Integer) v6.get("OP_POST_NOTIFICATION", new Class[]{Integer.TYPE}).target).intValue()), Integer.valueOf(v4_1), v5}).target).intValue() != 0) {
                return 0;
            }
        } catch (Throwable v0_1) {
            v0_1.printStackTrace();
            return v1;
        }

        return 1;
    }

    public static String z() {
        String v0 = com.bytedance.ttnet.cc.a().e();
        if (TextUtils.isEmpty(v0)) {
            v0 = ".snssdk.com";
        }
        return v0;
    }

    public static boolean z(String arg5) {
        boolean v0 = false;
        if (arg5 != null) {
            int v2 = arg5.length();
            if (v2 >= 13 && v2 <= 160) {
                int v1;
                for (v1 = 0; v1 < v2; ++v1) {
                    int v3 = arg5.charAt(v1);
                    if ((v3 < 48 || v3 > 57) && (v3 < 97 || v3 > 102) && (v3 < 65 || v3 > 70) && v3 != 45) {
                        return v0;
                    }
                }

                v0 = true;
            }
        }

        return v0;
    }

    public Object createFromParcel(Parcel arg2, ClassLoader arg3) {
        return new ParcelableSparseArray(arg2, arg3);
    }

    public Object[] newArray(int arg2) {
        return new ParcelableSparseArray[arg2];
    }

    @Override
    public void f(@NonNull Object o) {

    }

    public static final class a$a {
        public static final int A = 3;
        public static final int B = 2;
        public static final int C = 5;
        public static final int D = 0;
        public static final int E = 1;
        public static final int F = 7;
        public static final int G = 6;
        public static final int H = 4;
        public static final int I = 15;
        public static final int J = 14;
        public static final int K = 13;
        public static final int L = 11;
        public static final int M = 12;
        public static final int N = 10;
        public static final int O = 8;
        public static final int P = 9;
        public static final int[] Q = new int[]{16842901, 16842902, 16842903, 16842904, 16843105, 16843106, 16843107, 16843108, com.ss.android.article.browser.R.attr.ak};
        public static final int R = 4;
        public static final int S = 5;
        public static final int T = 6;
        public static final int U = 7;
        public static final int V = 3;
        public static final int W = 0;
        public static final int[] a;
        public static final int b = 0;
        public static final int c = 1;
        public static final int[] d;
        public static final int e = 1;
        public static final int f = 0;
        public static final int[] g;
        public static final int[] h;
        public static final int i = 0;
        public static final int j = 2;
        public static final int k = 4;
        public static final int l = 1;
        public static final int m = 3;
        public static final int n = 0;
        public static final int o = 1;
        public static final int[] p = new int[]{16843017, 16843264, com.ss.android.article.browser.R.attr.ft};
        public static final int q = 0;
        public static final int r = 1;
        public static final int s = 2;
        public static final int[] t;
        public static final int u = 0;
        public static final int[] v;
        public static final int w = 0;
        public static final int x = 1;
        public static final int y = 2;
        public static final int[] z;

        static {
            int[] v0 = new int[]{com.ss.android.article.browser.R.attr.e,
                    com.ss.android.article.browser.R.attr.i,
                    com.ss.android.article.browser.R.attr.j,
                    com.ss.android.article.browser.R.attr.k,
                    com.ss.android.article.browser.R.attr.l,
                    com.ss.android.article.browser.R.attr.m,
                    com.ss.android.article.browser.R.attr.n,
                    com.ss.android.article.browser.R.attr.o,
                    com.ss.android.article.browser.R.attr.p,
                    com.ss.android.article.browser.R.attr.q,
                    com.ss.android.article.browser.R.attr.r,
                    com.ss.android.article.browser.R.attr.s,
                    com.ss.android.article.browser.R.attr.t,
                    com.ss.android.article.browser.R.attr.u,
                    com.ss.android.article.browser.R.attr.v,
                    com.ss.android.article.browser.R.attr.w,
                    com.ss.android.article.browser.R.attr.x,
                    com.ss.android.article.browser.R.attr.y,
                    com.ss.android.article.browser.R.attr.z,
                    com.ss.android.article.browser.R.attr.a0,
                    com.ss.android.article.browser.R.attr.a1,
                    com.ss.android.article.browser.R.attr.a2,
                    com.ss.android.article.browser.R.attr.a3,
                    com.ss.android.article.browser.R.attr.a4,
                    com.ss.android.article.browser.R.attr.a5,
                    com.ss.android.article.browser.R.attr.a6,
                    com.ss.android.article.browser.R.attr.bu};
//            new int[1][0] = 16842931;
//            new int[1][0] = 16843071;
            v0 = new int[]{com.ss.android.article.browser.R.attr.e,
                    com.ss.android.article.browser.R.attr.m,
                    com.ss.android.article.browser.R.attr.n,
                    com.ss.android.article.browser.R.attr.r,
                    com.ss.android.article.browser.R.attr.t,
                    com.ss.android.article.browser.R.attr.a7};
            v0 = new int[]{com.ss.android.article.browser.R.attr.a8, com.ss.android.article.browser.R.attr.a9};
            v0 = new int[]{16842994, com.ss.android.article.browser.R.attr.a_,
                    com.ss.android.article.browser.R.attr.aa,
                    com.ss.android.article.browser.R.attr.ab,
                    com.ss.android.article.browser.R.attr.ac,
                    com.ss.android.article.browser.R.attr.ad};
            v0 = new int[]{16842964, com.ss.android.article.browser.R.attr.a5, com.ss.android.article.browser.R.attr.ag};
            a = new int[]{com.ss.android.article.browser.R.attr.ah, com.ss.android.article.browser.R.attr.ai};
            v0 = new int[]{16843033, com.ss.android.article.browser.R.attr.aj};
            v0 = new int[]{16842804, com.ss.android.article.browser.R.attr.ak};
            v0 = new int[]{16842839, 16842926, com.ss.android.article.browser.R.attr.c,
                    com.ss.android.article.browser.R.attr.al,
                    com.ss.android.article.browser.R.attr.am,
                    com.ss.android.article.browser.R.attr.an,
                    com.ss.android.article.browser.R.attr.ao,
                    com.ss.android.article.browser.R.attr.ap,
                    com.ss.android.article.browser.R.attr.aq,
                    com.ss.android.article.browser.R.attr.ar,
                    com.ss.android.article.browser.R.attr.as,
                    com.ss.android.article.browser.R.attr.at,
                    com.ss.android.article.browser.R.attr.au,
                    com.ss.android.article.browser.R.attr.av,
                    com.ss.android.article.browser.R.attr.actionBarTabBarStyle,
                    com.ss.android.article.browser.R.attr.ax,
                    com.ss.android.article.browser.R.attr.ay,
                    com.ss.android.article.browser.R.attr.az,
                    com.ss.android.article.browser.R.attr.b0,
                    com.ss.android.article.browser.R.attr.actionBarStyle,
                    com.ss.android.article.browser.R.attr.b2,
                    com.ss.android.article.browser.R.attr.b3,
                    com.ss.android.article.browser.R.attr.b4,
                    com.ss.android.article.browser.R.attr.b5,
                    com.ss.android.article.browser.R.attr.b6,
                    com.ss.android.article.browser.R.attr.b7,
                    com.ss.android.article.browser.R.attr.b8,
                    com.ss.android.article.browser.R.attr.b9,
                    com.ss.android.article.browser.R.attr.actionModeStyle,
                    com.ss.android.article.browser.R.attr.actionModeCloseButtonStyle,
                    com.ss.android.article.browser.R.attr.bb,
                    com.ss.android.article.browser.R.attr.bc,
                    com.ss.android.article.browser.R.attr.bd,
                    com.ss.android.article.browser.R.attr.be,
                    com.ss.android.article.browser.R.attr.bf,
                    com.ss.android.article.browser.R.attr.bg,
                    com.ss.android.article.browser.R.attr.bh,
                    com.ss.android.article.browser.R.attr.bi,
                    com.ss.android.article.browser.R.attr.bj,
                    com.ss.android.article.browser.R.attr.bk,
                    com.ss.android.article.browser.R.attr.bl,
                    com.ss.android.article.browser.R.attr.bm,
                    com.ss.android.article.browser.R.attr.bn,
                    com.ss.android.article.browser.R.attr.bo,
                    com.ss.android.article.browser.R.attr.bp,
                    com.ss.android.article.browser.R.attr.bq,
                    com.ss.android.article.browser.R.attr.br,
                    com.ss.android.article.browser.R.attr.bs,
                    com.ss.android.article.browser.R.attr.spinnerDropDownItemStyle,
                    com.ss.android.article.browser.R.attr.bu,
                    com.ss.android.article.browser.R.attr.actionButtonStyle,
                    com.ss.android.article.browser.R.attr.buttonBarStyle,
                    com.ss.android.article.browser.R.attr.bx,
                    com.ss.android.article.browser.R.attr.by,
                    com.ss.android.article.browser.R.attr.bz,
                    com.ss.android.article.browser.R.attr.borderlessButtonStyle,
                    com.ss.android.article.browser.R.attr.c1,
                    com.ss.android.article.browser.R.attr.c2,
                    com.ss.android.article.browser.R.attr.activityChooserViewStyle,
                    com.ss.android.article.browser.R.attr.toolbarStyle,
                    com.ss.android.article.browser.R.attr.c5,
                    com.ss.android.article.browser.R.attr.c6,
                    com.ss.android.article.browser.R.attr.c7,
                    com.ss.android.article.browser.R.attr.c8,
                    com.ss.android.article.browser.R.attr.c9,
                    com.ss.android.article.browser.R.attr.c_,
                    com.ss.android.article.browser.R.attr.ca,
                    com.ss.android.article.browser.R.attr.cb,
                    com.ss.android.article.browser.R.attr.cc,
                    com.ss.android.article.browser.R.attr.cd,
                    com.ss.android.article.browser.R.attr.ce,
                    com.ss.android.article.browser.R.attr.cf,
                    com.ss.android.article.browser.R.attr.cg,
                    com.ss.android.article.browser.R.attr.ch,
                    com.ss.android.article.browser.R.attr.ci,
                    com.ss.android.article.browser.R.attr.cj,
                    com.ss.android.article.browser.R.attr.ck,
                    com.ss.android.article.browser.R.attr.cl,
                    com.ss.android.article.browser.R.attr.cm,
                    com.ss.android.article.browser.R.attr.cn,
                    com.ss.android.article.browser.R.attr.co,
                    com.ss.android.article.browser.R.attr.cp,
                    com.ss.android.article.browser.R.attr.cq,
                    com.ss.android.article.browser.R.attr.cr,
                    com.ss.android.article.browser.R.attr.cs,
                    com.ss.android.article.browser.R.attr.ct,
                    com.ss.android.article.browser.R.attr.cu,
                    com.ss.android.article.browser.R.attr.cv,
                    com.ss.android.article.browser.R.attr.cw,
                    com.ss.android.article.browser.R.attr.cx,
                    com.ss.android.article.browser.R.attr.cy,
                    com.ss.android.article.browser.R.attr.cz,
                    com.ss.android.article.browser.R.attr.d0,
                    com.ss.android.article.browser.R.attr.d1,
                    com.ss.android.article.browser.R.attr.d2,
                    com.ss.android.article.browser.R.attr.d3,
                    com.ss.android.article.browser.R.attr.buttonBarPositiveButtonStyle,
                    com.ss.android.article.browser.R.attr.buttonBarNegativeButtonStyle,
                    com.ss.android.article.browser.R.attr.buttonBarNeutralButtonStyle,
                    com.ss.android.article.browser.R.attr.d7,
                    com.ss.android.article.browser.R.attr.d8,
                    com.ss.android.article.browser.R.attr.d9,
                    com.ss.android.article.browser.R.attr.d_,
                    com.ss.android.article.browser.R.attr.da,
                    com.ss.android.article.browser.R.attr.db,
                    com.ss.android.article.browser.R.attr.dc,
                    com.ss.android.article.browser.R.attr.dd,
                    com.ss.android.article.browser.R.attr.de,
                    com.ss.android.article.browser.R.attr.df,
                    com.ss.android.article.browser.R.attr.dg,
                    com.ss.android.article.browser.R.attr.dh,
                    com.ss.android.article.browser.R.attr.di};
            d = new int[]{com.ss.android.article.browser.R.attr.dr, com.ss.android.article.browser.R.attr.ds};
//            new int[1][0] = com.ss.android.article.browser.R.attr.dv;
            v0 = new int[]{com.ss.android.article.browser.R.attr.dz, com.ss.android.article.browser.R.attr.e0};
            v0 = new int[]{com.ss.android.article.browser.R.attr.i, com.ss.android.article.browser.R.attr.e1, com.ss.android.article.browser.R.attr.e2, com.ss.android.article.browser.R.attr.e3, com.ss.android.article.browser.R.attr.e4, com.ss.android.article.browser.R.attr.e5, com.ss.android.article.browser.R.attr.e6, com.ss.android.article.browser.R.attr.e7, com.ss.android.article.browser.R.attr.e8, com.ss.android.article.browser.R.attr.e9, com.ss.android.article.browser.R.attr.e_, com.ss.android.article.browser.R.attr.ea, com.ss.android.article.browser.R.attr.eb, com.ss.android.article.browser.R.attr.ec};
            v0 = new int[]{16843015, com.ss.android.article.browser.R.attr.ed, com.ss.android.article.browser.R.attr.ee};
            g = new int[]{com.ss.android.article.browser.R.attr.ef, com.ss.android.article.browser.R.attr.eg};
            h = new int[]{16842931, com.ss.android.article.browser.R.attr.eh, com.ss.android.article.browser.R.attr.ei, com.ss.android.article.browser.R.attr.ej, com.ss.android.article.browser.R.attr.ek};
            v0 = new int[]{com.ss.android.article.browser.R.attr.el,
                    com.ss.android.article.browser.R.attr.bottomSheetStyle,
                    com.ss.android.article.browser.R.attr.en};
            v0 = new int[]{com.ss.android.article.browser.R.attr.f_, com.ss.android.article.browser.R.attr.fa,
                    com.ss.android.article.browser.R.attr.fb, com.ss.android.article.browser.R.attr.fc,
                    com.ss.android.article.browser.R.attr.fd, com.ss.android.article.browser.R.attr.fe,
                    com.ss.android.article.browser.R.attr.ff, com.ss.android.article.browser.R.attr.fg};
            v0 = new int[]{com.ss.android.article.browser.R.attr.a5, com.ss.android.article.browser.R.attr.fh,
                    com.ss.android.article.browser.R.attr.fi, com.ss.android.article.browser.R.attr.fj,
                    com.ss.android.article.browser.R.attr.fk, com.ss.android.article.browser.R.attr.fl,
                    com.ss.android.article.browser.R.attr.kp, com.ss.android.article.browser.R.attr.kq};

            v0 = new int[]{16842927, 16842948, 16843046, 16843047, 16843048, com.ss.android.article.browser.R.attr.q,
                    com.ss.android.article.browser.R.attr.gj, com.ss.android.article.browser.R.attr.gk,
                    com.ss.android.article.browser.R.attr.gl};
            v0 = new int[]{16842931, 16842996, 16842997, 16843137};
            v0 = new int[]{16843436, 16843437};
            v0 = new int[]{16842766, 16842960, 16843156, 16843230, 16843231, 16843232};
            v0 = new int[]{16842754, 16842766, 16842960, 16843014, 16843156, 16843230, 16843231, 16843233, 16843234, 16843235, 16843236, 16843237, 16843375, com.ss.android.article.browser.R.attr.gp, com.ss.android.article.browser.R.attr.gq, com.ss.android.article.browser.R.attr.gr, com.ss.android.article.browser.R.attr.gs};
            v0 = new int[]{16842926, 16843052, 16843053, 16843054, 16843055, 16843056, 16843057,
                    com.ss.android.article.browser.R.attr.gt};
            v0 = new int[]{16842964, 16842973, 16843039, com.ss.android.article.browser.R.attr.a5,
                    com.ss.android.article.browser.R.attr.h2, com.ss.android.article.browser.R.attr.h3,
                    com.ss.android.article.browser.R.attr.h4, com.ss.android.article.browser.R.attr.h5,
                    com.ss.android.article.browser.R.attr.h6, com.ss.android.article.browser.R.attr.h7};
            v0 = new int[]{16843126, com.ss.android.article.browser.R.attr.h_};
//            new int[1][0] = com.ss.android.article.browser.R.attr.ha;
            v0 = new int[]{16842948, com.ss.android.article.browser.R.attr.i2,
                    com.ss.android.article.browser.R.attr.i3, com.ss.android.article.browser.R.attr.i4, com.ss.android.article.browser.R.attr.i5};
//            new int[1][0] = com.ss.android.article.browser.R.attr.ij;
            v0 = new int[]{com.ss.android.article.browser.R.attr.il};
            t = v0;
            v0 = new int[]{16842970, 16843039, 16843296, 16843364, com.ss.android.article.browser.R.attr.im, com.ss.android.article.browser.R.attr.in, com.ss.android.article.browser.R.attr.io, com.ss.android.article.browser.R.attr.ip, com.ss.android.article.browser.R.attr.iq, com.ss.android.article.browser.R.attr.ir, com.ss.android.article.browser.R.attr.is, com.ss.android.article.browser.R.attr.it, com.ss.android.article.browser.R.attr.iu, com.ss.android.article.browser.R.attr.iv, com.ss.android.article.browser.R.attr.iw, com.ss.android.article.browser.R.attr.ix, com.ss.android.article.browser.R.attr.iy};
            v = new int[]{16843039, com.ss.android.article.browser.R.attr.a5, com.ss.android.article.browser.R.attr.j6};
            v0 = new int[]{16842930, 16843126, 16843131, 16843362, com.ss.android.article.browser.R.attr.a6};
            v0 = new int[]{16843044, 16843045, 16843074, com.ss.android.article.browser.R.attr.j7, com.ss.android.article.browser.R.attr.j8, com.ss.android.article.browser.R.attr.j9, com.ss.android.article.browser.R.attr.j_, com.ss.android.article.browser.R.attr.ja, com.ss.android.article.browser.R.attr.jb, com.ss.android.article.browser.R.attr.jc};
            v0 = new int[]{16842754, 16842994, 16843087};
            z = new int[]{com.ss.android.article.browser.R.attr.jd, com.ss.android.article.browser.R.attr.je, com.ss.android.article.browser.R.attr.jf, com.ss.android.article.browser.R.attr.jg, com.ss.android.article.browser.R.attr.jh, com.ss.android.article.browser.R.attr.ji, com.ss.android.article.browser.R.attr.jj, com.ss.android.article.browser.R.attr.jk, com.ss.android.article.browser.R.attr.jl, com.ss.android.article.browser.R.attr.jm, com.ss.android.article.browser.R.attr.jn, com.ss.android.article.browser.R.attr.jo, com.ss.android.article.browser.R.attr.jp, com.ss.android.article.browser.R.attr.jq, com.ss.android.article.browser.R.attr.jr, com.ss.android.article.browser.R.attr.js};

            v0 = new int[]{16842906,
                    16843088,
                    com.ss.android.article.browser.R.attr.jw,
                    com.ss.android.article.browser.R.attr.jx,
                    com.ss.android.article.browser.R.attr.jy,
                    com.ss.android.article.browser.R.attr.jz,
                    com.ss.android.article.browser.R.attr.k0,
                    com.ss.android.article.browser.R.attr.k1,
                    com.ss.android.article.browser.R.attr.k2,
                    com.ss.android.article.browser.R.attr.k3,
                    com.ss.android.article.browser.R.attr.k4};
            v0 = new int[]{16842927, 16843072,
                    com.ss.android.article.browser.R.attr.i,
                    com.ss.android.article.browser.R.attr.l,
                    com.ss.android.article.browser.R.attr.p,
                    com.ss.android.article.browser.R.attr.a1,
                    com.ss.android.article.browser.R.attr.a2,
                    com.ss.android.article.browser.R.attr.a3,
                    com.ss.android.article.browser.R.attr.a4,
                    com.ss.android.article.browser.R.attr.a6,
                    com.ss.android.article.browser.R.attr.k8,
                    com.ss.android.article.browser.R.attr.k9,
                    com.ss.android.article.browser.R.attr.k_,
                    com.ss.android.article.browser.R.attr.ka,
                    com.ss.android.article.browser.R.attr.kb,
                    com.ss.android.article.browser.R.attr.kc,
                    com.ss.android.article.browser.R.attr.kd,
                    com.ss.android.article.browser.R.attr.ke,
                    com.ss.android.article.browser.R.attr.kf,
                    com.ss.android.article.browser.R.attr.kg,
                    com.ss.android.article.browser.R.attr.kh,
                    com.ss.android.article.browser.R.attr.ki,
                    com.ss.android.article.browser.R.attr.kj,
                    com.ss.android.article.browser.R.attr.kk,
                    com.ss.android.article.browser.R.attr.kl};
            v0 = new int[]{16842752, 16842970,
                    com.ss.android.article.browser.R.attr.km,
                    com.ss.android.article.browser.R.attr.kn,
                    com.ss.android.article.browser.R.attr.ko};
            v0 = new int[]{16842964, com.ss.android.article.browser.R.attr.kp, com.ss.android.article.browser.R.attr.kq};
            v0 = new int[]{16842960, 16842994, 16842995};
        }
    }
}

